f1d58c2521
Within mac80211, we often need to copy the rx status into skb->cb. This is wasteful, as drivers could be building it in there to start with. This patch changes the API so that drivers are expected to pass the RX status in skb->cb, now accessible as IEEE80211_SKB_RXCB(skb). It also updates all drivers to pass the rx status in there, but only by making them memcpy() it into place before the call to the receive function (ieee80211_rx(_irqsafe)). Each driver can now be optimised on its own schedule. Signed-off-by: Johannes Berg <johannes@sipsolutions.net> Signed-off-by: John W. Linville <linville@tuxdriver.com>
2605 lines
75 KiB
C
2605 lines
75 KiB
C
/*
|
|
* This file is part of stlc45xx
|
|
*
|
|
* Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).
|
|
*
|
|
* Contact: Kalle Valo <kalle.valo@nokia.com>
|
|
*
|
|
* 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, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
|
|
* 02110-1301 USA
|
|
*
|
|
*/
|
|
|
|
#include "stlc45xx.h"
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/firmware.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/irq.h>
|
|
#include <linux/spi/spi.h>
|
|
#include <linux/etherdevice.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/moduleparam.h>
|
|
|
|
#include "stlc45xx_lmac.h"
|
|
|
|
/*
|
|
* gpios should be handled in board files and provided via platform data,
|
|
* but because it's currently impossible for stlc45xx to have a header file
|
|
* in include/linux, let's use module paramaters for now
|
|
*/
|
|
static int stlc45xx_gpio_power = 97;
|
|
module_param(stlc45xx_gpio_power, int, 0444);
|
|
MODULE_PARM_DESC(stlc45xx_gpio_power, "stlc45xx gpio number for power line");
|
|
|
|
static int stlc45xx_gpio_irq = 87;
|
|
module_param(stlc45xx_gpio_irq, int, 0444);
|
|
MODULE_PARM_DESC(stlc45xx_gpio_irq, "stlc45xx gpio number for irq line");
|
|
|
|
static const u8 default_cal_channels[] = {
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x09,
|
|
0x00, 0x00, 0xc9, 0xff, 0xd8, 0xff, 0x00, 0x00, 0x00, 0x01, 0x10,
|
|
0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0xe0, 0x00, 0xe0, 0x00,
|
|
0xe0, 0x00, 0xe0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0,
|
|
0x00, 0x54, 0x01, 0xab, 0xf6, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42,
|
|
0xc0, 0x42, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00,
|
|
0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x22, 0x01, 0x37, 0xa9,
|
|
0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0x00, 0xbc, 0x00,
|
|
0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc,
|
|
0x00, 0xbc, 0xfb, 0x00, 0xca, 0x79, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0,
|
|
0x2b, 0xc0, 0x2b, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4,
|
|
0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0xd0, 0x00, 0x5d,
|
|
0x54, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0x00, 0xaa,
|
|
0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00,
|
|
0xaa, 0x00, 0xaa, 0xa7, 0x00, 0xa9, 0x3d, 0xc0, 0x17, 0xc0, 0x17,
|
|
0xc0, 0x17, 0xc0, 0x17, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00,
|
|
0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x7a, 0x00,
|
|
0x06, 0x2c, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0x00,
|
|
0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96,
|
|
0x00, 0x96, 0x00, 0x96, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x06, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x71, 0x09, 0x00, 0x00, 0xc9, 0xff, 0xd8,
|
|
0xff, 0x00, 0x00, 0x00, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01,
|
|
0x10, 0x01, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xd0,
|
|
0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0x54, 0x01, 0xab, 0xf6,
|
|
0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0x00, 0xcb, 0x00,
|
|
0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb,
|
|
0x00, 0xcb, 0x22, 0x01, 0x37, 0xa9, 0xc0, 0x33, 0xc0, 0x33, 0xc0,
|
|
0x33, 0xc0, 0x33, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc,
|
|
0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0xfb, 0x00, 0xca,
|
|
0x79, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0x00, 0xb4,
|
|
0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00,
|
|
0xb4, 0x00, 0xb4, 0xd0, 0x00, 0x5d, 0x54, 0xc0, 0x21, 0xc0, 0x21,
|
|
0xc0, 0x21, 0xc0, 0x21, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00,
|
|
0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0xa7, 0x00,
|
|
0xa9, 0x3d, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0x00,
|
|
0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0,
|
|
0x00, 0xa0, 0x00, 0xa0, 0x7a, 0x00, 0x06, 0x2c, 0xc0, 0x0d, 0xc0,
|
|
0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96,
|
|
0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x80, 0x80,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76,
|
|
0x09, 0x00, 0x00, 0xc9, 0xff, 0xd8, 0xff, 0x00, 0x00, 0x00, 0x01,
|
|
0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0xf0, 0x00, 0xf0,
|
|
0x00, 0xf0, 0x00, 0xf0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00,
|
|
0xd0, 0x00, 0x54, 0x01, 0xab, 0xf6, 0xc0, 0x42, 0xc0, 0x42, 0xc0,
|
|
0x42, 0xc0, 0x42, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb,
|
|
0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x22, 0x01, 0x37,
|
|
0xa9, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0x00, 0xbc,
|
|
0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00,
|
|
0xbc, 0x00, 0xbc, 0xfb, 0x00, 0xca, 0x79, 0xc0, 0x2b, 0xc0, 0x2b,
|
|
0xc0, 0x2b, 0xc0, 0x2b, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00,
|
|
0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0xd0, 0x00,
|
|
0x5d, 0x54, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0x00,
|
|
0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa,
|
|
0x00, 0xaa, 0x00, 0xaa, 0xa7, 0x00, 0xa9, 0x3d, 0xc0, 0x17, 0xc0,
|
|
0x17, 0xc0, 0x17, 0xc0, 0x17, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0,
|
|
0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x7a,
|
|
0x00, 0x06, 0x2c, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d,
|
|
0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00,
|
|
0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x06, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x7b, 0x09, 0x00, 0x00, 0xc9, 0xff,
|
|
0xd8, 0xff, 0x00, 0x00, 0x00, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10,
|
|
0x01, 0x10, 0x01, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00,
|
|
0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0x54, 0x01, 0xab,
|
|
0xf6, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0x00, 0xcb,
|
|
0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00,
|
|
0xcb, 0x00, 0xcb, 0x22, 0x01, 0x37, 0xa9, 0xc0, 0x33, 0xc0, 0x33,
|
|
0xc0, 0x33, 0xc0, 0x33, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00,
|
|
0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0xfb, 0x00,
|
|
0xca, 0x79, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0x00,
|
|
0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4,
|
|
0x00, 0xb4, 0x00, 0xb4, 0xd0, 0x00, 0x5d, 0x54, 0xc0, 0x21, 0xc0,
|
|
0x21, 0xc0, 0x21, 0xc0, 0x21, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa,
|
|
0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0xa7,
|
|
0x00, 0xa9, 0x3d, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17,
|
|
0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00,
|
|
0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x7a, 0x00, 0x06, 0x2c, 0xc0, 0x0d,
|
|
0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0x00, 0x96, 0x00, 0x96, 0x00,
|
|
0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x80,
|
|
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x80, 0x09, 0x00, 0x00, 0xc9, 0xff, 0xd8, 0xff, 0x00, 0x00, 0x00,
|
|
0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0xf0, 0x00,
|
|
0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0,
|
|
0x00, 0xd0, 0x00, 0x54, 0x01, 0xab, 0xf6, 0xc0, 0x42, 0xc0, 0x42,
|
|
0xc0, 0x42, 0xc0, 0x42, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00,
|
|
0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x22, 0x01,
|
|
0x37, 0xa9, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0x00,
|
|
0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc,
|
|
0x00, 0xbc, 0x00, 0xbc, 0xfb, 0x00, 0xca, 0x79, 0xc0, 0x2b, 0xc0,
|
|
0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4,
|
|
0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0xd0,
|
|
0x00, 0x5d, 0x54, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21,
|
|
0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00,
|
|
0xaa, 0x00, 0xaa, 0x00, 0xaa, 0xa7, 0x00, 0xa9, 0x3d, 0xc0, 0x17,
|
|
0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0x00, 0xa0, 0x00, 0xa0, 0x00,
|
|
0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0,
|
|
0x7a, 0x00, 0x06, 0x2c, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0,
|
|
0x0d, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96,
|
|
0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x06, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x85, 0x09, 0x00, 0x00, 0xc9,
|
|
0xff, 0xd8, 0xff, 0x00, 0x00, 0x00, 0x01, 0x10, 0x01, 0x10, 0x01,
|
|
0x10, 0x01, 0x10, 0x01, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xf0,
|
|
0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0x54, 0x01,
|
|
0xab, 0xf6, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0x00,
|
|
0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb,
|
|
0x00, 0xcb, 0x00, 0xcb, 0x22, 0x01, 0x37, 0xa9, 0xc0, 0x33, 0xc0,
|
|
0x33, 0xc0, 0x33, 0xc0, 0x33, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc,
|
|
0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0xfb,
|
|
0x00, 0xca, 0x79, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b,
|
|
0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00,
|
|
0xb4, 0x00, 0xb4, 0x00, 0xb4, 0xd0, 0x00, 0x5d, 0x54, 0xc0, 0x21,
|
|
0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0x00, 0xaa, 0x00, 0xaa, 0x00,
|
|
0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa,
|
|
0xa7, 0x00, 0xa9, 0x3d, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0xc0,
|
|
0x17, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0,
|
|
0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x7a, 0x00, 0x06, 0x2c, 0xc0,
|
|
0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0x00, 0x96, 0x00, 0x96,
|
|
0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00,
|
|
0x96, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
|
|
0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x8a, 0x09, 0x00, 0x00, 0xc9, 0xff, 0xd8, 0xff, 0x00, 0x00,
|
|
0x00, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0xf0,
|
|
0x00, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xd0, 0x00, 0xd0, 0x00,
|
|
0xd0, 0x00, 0xd0, 0x00, 0x54, 0x01, 0xab, 0xf6, 0xc0, 0x42, 0xc0,
|
|
0x42, 0xc0, 0x42, 0xc0, 0x42, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb,
|
|
0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x22,
|
|
0x01, 0x37, 0xa9, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33,
|
|
0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00,
|
|
0xbc, 0x00, 0xbc, 0x00, 0xbc, 0xfb, 0x00, 0xca, 0x79, 0xc0, 0x2b,
|
|
0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0x00, 0xb4, 0x00, 0xb4, 0x00,
|
|
0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4,
|
|
0xd0, 0x00, 0x5d, 0x54, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0xc0,
|
|
0x21, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa,
|
|
0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0xa7, 0x00, 0xa9, 0x3d, 0xc0,
|
|
0x17, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0x00, 0xa0, 0x00, 0xa0,
|
|
0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00,
|
|
0xa0, 0x7a, 0x00, 0x06, 0x2c, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d,
|
|
0xc0, 0x0d, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00,
|
|
0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x80, 0x80, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8f, 0x09, 0x00, 0x00,
|
|
0xc9, 0xff, 0xd8, 0xff, 0x00, 0x00, 0x00, 0x01, 0x10, 0x01, 0x10,
|
|
0x01, 0x10, 0x01, 0x10, 0x01, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00,
|
|
0xf0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0x54,
|
|
0x01, 0xab, 0xf6, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42,
|
|
0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00,
|
|
0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x22, 0x01, 0x37, 0xa9, 0xc0, 0x33,
|
|
0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0x00, 0xbc, 0x00, 0xbc, 0x00,
|
|
0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc,
|
|
0xfb, 0x00, 0xca, 0x79, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0,
|
|
0x2b, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4,
|
|
0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0xd0, 0x00, 0x5d, 0x54, 0xc0,
|
|
0x21, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0x00, 0xaa, 0x00, 0xaa,
|
|
0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00,
|
|
0xaa, 0xa7, 0x00, 0xa9, 0x3d, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17,
|
|
0xc0, 0x17, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00,
|
|
0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x7a, 0x00, 0x06, 0x2c,
|
|
0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0x00, 0x96, 0x00,
|
|
0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96,
|
|
0x00, 0x96, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x06, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x94, 0x09, 0x00, 0x00, 0xc9, 0xff, 0xd8, 0xff, 0x00,
|
|
0x00, 0x00, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01,
|
|
0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xd0, 0x00, 0xd0,
|
|
0x00, 0xd0, 0x00, 0xd0, 0x00, 0x54, 0x01, 0xab, 0xf6, 0xc0, 0x42,
|
|
0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0x00, 0xcb, 0x00, 0xcb, 0x00,
|
|
0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb,
|
|
0x22, 0x01, 0x37, 0xa9, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0xc0,
|
|
0x33, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc,
|
|
0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0xfb, 0x00, 0xca, 0x79, 0xc0,
|
|
0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0x00, 0xb4, 0x00, 0xb4,
|
|
0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00,
|
|
0xb4, 0xd0, 0x00, 0x5d, 0x54, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21,
|
|
0xc0, 0x21, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00,
|
|
0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0xa7, 0x00, 0xa9, 0x3d,
|
|
0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0x00, 0xa0, 0x00,
|
|
0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0,
|
|
0x00, 0xa0, 0x7a, 0x00, 0x06, 0x2c, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0,
|
|
0x0d, 0xc0, 0x0d, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96,
|
|
0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x80, 0x80, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x99, 0x09, 0x00,
|
|
0x00, 0xc9, 0xff, 0xd8, 0xff, 0x00, 0x00, 0x00, 0x01, 0x10, 0x01,
|
|
0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0xf0, 0x00, 0xf0, 0x00, 0xf0,
|
|
0x00, 0xf0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00,
|
|
0x54, 0x01, 0xab, 0xf6, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0xc0,
|
|
0x42, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb,
|
|
0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x22, 0x01, 0x37, 0xa9, 0xc0,
|
|
0x33, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0x00, 0xbc, 0x00, 0xbc,
|
|
0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00,
|
|
0xbc, 0xfb, 0x00, 0xca, 0x79, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b,
|
|
0xc0, 0x2b, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00,
|
|
0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0xd0, 0x00, 0x5d, 0x54,
|
|
0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0x00, 0xaa, 0x00,
|
|
0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa,
|
|
0x00, 0xaa, 0xa7, 0x00, 0xa9, 0x3d, 0xc0, 0x17, 0xc0, 0x17, 0xc0,
|
|
0x17, 0xc0, 0x17, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0,
|
|
0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x7a, 0x00, 0x06,
|
|
0x2c, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0x00, 0x96,
|
|
0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00,
|
|
0x96, 0x00, 0x96, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x06, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x9e, 0x09, 0x00, 0x00, 0xc9, 0xff, 0xd8, 0xff,
|
|
0x00, 0x00, 0x00, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10,
|
|
0x01, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xd0, 0x00,
|
|
0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0x54, 0x01, 0xab, 0xf6, 0xc0,
|
|
0x42, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0x00, 0xcb, 0x00, 0xcb,
|
|
0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00,
|
|
0xcb, 0x22, 0x01, 0x37, 0xa9, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33,
|
|
0xc0, 0x33, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00,
|
|
0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0xfb, 0x00, 0xca, 0x79,
|
|
0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0x00, 0xb4, 0x00,
|
|
0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4,
|
|
0x00, 0xb4, 0xd0, 0x00, 0x5d, 0x54, 0xc0, 0x21, 0xc0, 0x21, 0xc0,
|
|
0x21, 0xc0, 0x21, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa,
|
|
0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0xa7, 0x00, 0xa9,
|
|
0x3d, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0x00, 0xa0,
|
|
0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00,
|
|
0xa0, 0x00, 0xa0, 0x7a, 0x00, 0x06, 0x2c, 0xc0, 0x0d, 0xc0, 0x0d,
|
|
0xc0, 0x0d, 0xc0, 0x0d, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00,
|
|
0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x80, 0x80, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00 };
|
|
|
|
static const u8 default_cal_rssi[] = {
|
|
0x0a, 0x01, 0x72, 0xfe, 0x1a, 0x00, 0x00, 0x00, 0x0a, 0x01, 0x72,
|
|
0xfe, 0x1a, 0x00, 0x00, 0x00, 0x0a, 0x01, 0x72, 0xfe, 0x1a, 0x00,
|
|
0x00, 0x00, 0x0a, 0x01, 0x72, 0xfe, 0x1a, 0x00, 0x00, 0x00, 0x0a,
|
|
0x01, 0x72, 0xfe, 0x1a, 0x00, 0x00, 0x00, 0x0a, 0x01, 0x72, 0xfe,
|
|
0x1a, 0x00, 0x00, 0x00, 0x0a, 0x01, 0x72, 0xfe, 0x1a, 0x00, 0x00,
|
|
0x00, 0x0a, 0x01, 0x72, 0xfe, 0x1a, 0x00, 0x00, 0x00, 0x0a, 0x01,
|
|
0x72, 0xfe, 0x1a, 0x00, 0x00, 0x00, 0x0a, 0x01, 0x72, 0xfe, 0x1a,
|
|
0x00, 0x00, 0x00, 0x0a, 0x01, 0x72, 0xfe, 0x1a, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00 };
|
|
|
|
static void stlc45xx_tx_edcf(struct stlc45xx *stlc);
|
|
static void stlc45xx_tx_setup(struct stlc45xx *stlc);
|
|
static void stlc45xx_tx_scan(struct stlc45xx *stlc);
|
|
static void stlc45xx_tx_psm(struct stlc45xx *stlc, bool enable);
|
|
static int stlc45xx_tx_nullfunc(struct stlc45xx *stlc, bool powersave);
|
|
static int stlc45xx_tx_pspoll(struct stlc45xx *stlc, bool powersave);
|
|
|
|
static ssize_t stlc45xx_sysfs_show_cal_rssi(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct stlc45xx *stlc = dev_get_drvdata(dev);
|
|
ssize_t len;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
len = PAGE_SIZE;
|
|
|
|
mutex_lock(&stlc->mutex);
|
|
|
|
if (stlc->cal_rssi)
|
|
hex_dump_to_buffer(stlc->cal_rssi, RSSI_CAL_ARRAY_LEN, 16,
|
|
2, buf, len, 0);
|
|
mutex_unlock(&stlc->mutex);
|
|
|
|
len = strlen(buf);
|
|
|
|
return len;
|
|
}
|
|
|
|
static ssize_t stlc45xx_sysfs_store_cal_rssi(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct stlc45xx *stlc = dev_get_drvdata(dev);
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
mutex_lock(&stlc->mutex);
|
|
|
|
if (count != RSSI_CAL_ARRAY_LEN) {
|
|
stlc45xx_error("invalid cal_rssi length: %zu", count);
|
|
count = 0;
|
|
goto out_unlock;
|
|
}
|
|
|
|
kfree(stlc->cal_rssi);
|
|
|
|
stlc->cal_rssi = kmemdup(buf, RSSI_CAL_ARRAY_LEN, GFP_KERNEL);
|
|
|
|
if (!stlc->cal_rssi) {
|
|
stlc45xx_error("failed to allocate memory for cal_rssi");
|
|
count = 0;
|
|
goto out_unlock;
|
|
}
|
|
|
|
out_unlock:
|
|
mutex_unlock(&stlc->mutex);
|
|
|
|
return count;
|
|
}
|
|
|
|
static ssize_t stlc45xx_sysfs_show_cal_channels(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct stlc45xx *stlc = dev_get_drvdata(dev);
|
|
ssize_t len;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
len = PAGE_SIZE;
|
|
|
|
mutex_lock(&stlc->mutex);
|
|
|
|
if (stlc->cal_channels)
|
|
hex_dump_to_buffer(stlc->cal_channels, CHANNEL_CAL_ARRAY_LEN,
|
|
16, 2, buf, len, 0);
|
|
|
|
mutex_unlock(&stlc->mutex);
|
|
|
|
len = strlen(buf);
|
|
|
|
return len;
|
|
}
|
|
|
|
static ssize_t stlc45xx_sysfs_store_cal_channels(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct stlc45xx *stlc = dev_get_drvdata(dev);
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
mutex_lock(&stlc->mutex);
|
|
|
|
if (count != CHANNEL_CAL_ARRAY_LEN) {
|
|
stlc45xx_error("invalid cal_channels size: %zu ", count);
|
|
count = 0;
|
|
goto out_unlock;
|
|
}
|
|
|
|
kfree(stlc->cal_channels);
|
|
|
|
stlc->cal_channels = kmemdup(buf, count, GFP_KERNEL);
|
|
|
|
if (!stlc->cal_channels) {
|
|
stlc45xx_error("failed to allocate memory for cal_channels");
|
|
count = 0;
|
|
goto out_unlock;
|
|
}
|
|
|
|
out_unlock:
|
|
mutex_unlock(&stlc->mutex);
|
|
|
|
return count;
|
|
}
|
|
|
|
static ssize_t stlc45xx_sysfs_show_tx_buf(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct stlc45xx *stlc = dev_get_drvdata(dev);
|
|
struct txbuffer *entry;
|
|
ssize_t len = 0;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s()", __func__);
|
|
|
|
mutex_lock(&stlc->mutex);
|
|
|
|
list_for_each_entry(entry, &stlc->tx_sent, tx_list) {
|
|
len += sprintf(buf + len, "0x%x: 0x%x-0x%x\n",
|
|
entry->handle, entry->start,
|
|
entry->end);
|
|
}
|
|
|
|
mutex_unlock(&stlc->mutex);
|
|
|
|
return len;
|
|
}
|
|
|
|
static DEVICE_ATTR(cal_rssi, S_IRUGO | S_IWUSR,
|
|
stlc45xx_sysfs_show_cal_rssi,
|
|
stlc45xx_sysfs_store_cal_rssi);
|
|
static DEVICE_ATTR(cal_channels, S_IRUGO | S_IWUSR,
|
|
stlc45xx_sysfs_show_cal_channels,
|
|
stlc45xx_sysfs_store_cal_channels);
|
|
static DEVICE_ATTR(tx_buf, S_IRUGO, stlc45xx_sysfs_show_tx_buf, NULL);
|
|
|
|
static void stlc45xx_spi_read(struct stlc45xx *stlc, unsigned long addr,
|
|
void *buf, size_t len)
|
|
{
|
|
struct spi_transfer t[2];
|
|
struct spi_message m;
|
|
|
|
/* We first push the address */
|
|
addr = (addr << 8) | ADDR_READ_BIT_15;
|
|
|
|
spi_message_init(&m);
|
|
memset(t, 0, sizeof(t));
|
|
|
|
t[0].tx_buf = &addr;
|
|
t[0].len = 2;
|
|
spi_message_add_tail(&t[0], &m);
|
|
|
|
t[1].rx_buf = buf;
|
|
t[1].len = len;
|
|
spi_message_add_tail(&t[1], &m);
|
|
|
|
spi_sync(stlc->spi, &m);
|
|
}
|
|
|
|
|
|
static void stlc45xx_spi_write(struct stlc45xx *stlc, unsigned long addr,
|
|
void *buf, size_t len)
|
|
{
|
|
struct spi_transfer t[3];
|
|
struct spi_message m;
|
|
u16 last_word;
|
|
|
|
/* We first push the address */
|
|
addr = addr << 8;
|
|
|
|
spi_message_init(&m);
|
|
memset(t, 0, sizeof(t));
|
|
|
|
t[0].tx_buf = &addr;
|
|
t[0].len = 2;
|
|
spi_message_add_tail(&t[0], &m);
|
|
|
|
t[1].tx_buf = buf;
|
|
t[1].len = len;
|
|
spi_message_add_tail(&t[1], &m);
|
|
|
|
if (len % 2) {
|
|
last_word = ((u8 *)buf)[len - 1];
|
|
|
|
t[2].tx_buf = &last_word;
|
|
t[2].len = 2;
|
|
spi_message_add_tail(&t[2], &m);
|
|
}
|
|
|
|
spi_sync(stlc->spi, &m);
|
|
}
|
|
|
|
static u16 stlc45xx_read16(struct stlc45xx *stlc, unsigned long addr)
|
|
{
|
|
u16 val;
|
|
|
|
stlc45xx_spi_read(stlc, addr, &val, sizeof(val));
|
|
|
|
return val;
|
|
}
|
|
|
|
static u32 stlc45xx_read32(struct stlc45xx *stlc, unsigned long addr)
|
|
{
|
|
u32 val;
|
|
|
|
stlc45xx_spi_read(stlc, addr, &val, sizeof(val));
|
|
|
|
return val;
|
|
}
|
|
|
|
static void stlc45xx_write16(struct stlc45xx *stlc, unsigned long addr, u16 val)
|
|
{
|
|
stlc45xx_spi_write(stlc, addr, &val, sizeof(val));
|
|
}
|
|
|
|
static void stlc45xx_write32(struct stlc45xx *stlc, unsigned long addr, u32 val)
|
|
{
|
|
stlc45xx_spi_write(stlc, addr, &val, sizeof(val));
|
|
}
|
|
|
|
struct stlc45xx_spi_reg {
|
|
u16 address;
|
|
u16 length;
|
|
char *name;
|
|
};
|
|
|
|
/* caller must hold tx_lock */
|
|
static void stlc45xx_txbuffer_dump(struct stlc45xx *stlc)
|
|
{
|
|
struct txbuffer *txbuffer;
|
|
char *buf, *pos;
|
|
int buf_len, l, count;
|
|
|
|
if (!(DEBUG_LEVEL & DEBUG_TXBUFFER))
|
|
return;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s()", __func__);
|
|
|
|
buf_len = 500;
|
|
buf = kmalloc(buf_len, GFP_ATOMIC);
|
|
if (!buf)
|
|
return;
|
|
|
|
pos = buf;
|
|
count = 0;
|
|
|
|
list_for_each_entry(txbuffer, &stlc->txbuffer, buffer_list) {
|
|
l = snprintf(pos, buf_len, "0x%x-0x%x,",
|
|
txbuffer->start, txbuffer->end);
|
|
/* drop the null byte */
|
|
pos += l;
|
|
buf_len -= l;
|
|
count++;
|
|
}
|
|
|
|
if (count == 0)
|
|
*pos = '\0';
|
|
else
|
|
*--pos = '\0';
|
|
|
|
stlc45xx_debug(DEBUG_TXBUFFER, "txbuffer: in buffer %d regions: %s",
|
|
count, buf);
|
|
|
|
kfree(buf);
|
|
}
|
|
|
|
/* caller must hold tx_lock */
|
|
static int stlc45xx_txbuffer_find(struct stlc45xx *stlc, size_t len)
|
|
{
|
|
struct txbuffer *txbuffer;
|
|
int pos;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s()", __func__);
|
|
|
|
pos = FIRMWARE_TXBUFFER_START;
|
|
|
|
if (list_empty(&stlc->txbuffer))
|
|
goto out;
|
|
|
|
/*
|
|
* the entries in txbuffer must be in the same order as they are in
|
|
* the real buffer
|
|
*/
|
|
list_for_each_entry(txbuffer, &stlc->txbuffer, buffer_list) {
|
|
if (pos + len < txbuffer->start)
|
|
break;
|
|
pos = ALIGN(txbuffer->end + 1, 4);
|
|
}
|
|
|
|
if (pos + len > FIRMWARE_TXBUFFER_END)
|
|
/* not enough room */
|
|
pos = -1;
|
|
|
|
stlc45xx_debug(DEBUG_TXBUFFER, "txbuffer: find %zu B: 0x%x", len, pos);
|
|
|
|
out:
|
|
return pos;
|
|
}
|
|
|
|
static int stlc45xx_txbuffer_add(struct stlc45xx *stlc,
|
|
struct txbuffer *txbuffer)
|
|
{
|
|
struct txbuffer *r, *prev = NULL;
|
|
|
|
if (list_empty(&stlc->txbuffer)) {
|
|
list_add(&txbuffer->buffer_list, &stlc->txbuffer);
|
|
return 0;
|
|
}
|
|
|
|
r = list_first_entry(&stlc->txbuffer, struct txbuffer, buffer_list);
|
|
|
|
if (txbuffer->start < r->start) {
|
|
/* add to the beginning of the list */
|
|
list_add(&txbuffer->buffer_list, &stlc->txbuffer);
|
|
return 0;
|
|
}
|
|
|
|
prev = NULL;
|
|
list_for_each_entry(r, &stlc->txbuffer, buffer_list) {
|
|
/* skip first entry, we checked for that above */
|
|
if (!prev) {
|
|
prev = r;
|
|
continue;
|
|
}
|
|
|
|
/* double-check overlaps */
|
|
WARN_ON_ONCE(txbuffer->start >= r->start &&
|
|
txbuffer->start <= r->end);
|
|
WARN_ON_ONCE(txbuffer->end >= r->start &&
|
|
txbuffer->end <= r->end);
|
|
|
|
if (prev->end < txbuffer->start &&
|
|
txbuffer->end < r->start) {
|
|
/* insert at this spot */
|
|
list_add_tail(&txbuffer->buffer_list, &r->buffer_list);
|
|
return 0;
|
|
}
|
|
|
|
prev = r;
|
|
}
|
|
|
|
/* not found */
|
|
list_add_tail(&txbuffer->buffer_list, &stlc->txbuffer);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/* caller must hold tx_lock */
|
|
static struct txbuffer *stlc45xx_txbuffer_alloc(struct stlc45xx *stlc,
|
|
size_t frame_len)
|
|
{
|
|
struct txbuffer *entry = NULL;
|
|
size_t len;
|
|
int pos;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s()", __func__);
|
|
|
|
len = FIRMWARE_TXBUFFER_HEADER + frame_len + FIRMWARE_TXBUFFER_TRAILER;
|
|
pos = stlc45xx_txbuffer_find(stlc, len);
|
|
|
|
if (pos < 0)
|
|
return NULL;
|
|
|
|
WARN_ON_ONCE(pos + len > FIRMWARE_TXBUFFER_END);
|
|
WARN_ON_ONCE(pos < FIRMWARE_TXBUFFER_START);
|
|
|
|
entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
|
|
entry->start = pos;
|
|
entry->frame_start = pos + FIRMWARE_TXBUFFER_HEADER;
|
|
entry->end = entry->start + len - 1;
|
|
|
|
stlc45xx_debug(DEBUG_TXBUFFER, "txbuffer: allocated 0x%x-0x%x",
|
|
entry->start, entry->end);
|
|
|
|
stlc45xx_txbuffer_add(stlc, entry);
|
|
|
|
stlc45xx_txbuffer_dump(stlc);
|
|
|
|
return entry;
|
|
}
|
|
|
|
/* caller must hold tx_lock */
|
|
static void stlc45xx_txbuffer_free(struct stlc45xx *stlc,
|
|
struct txbuffer *txbuffer)
|
|
{
|
|
stlc45xx_debug(DEBUG_FUNC, "%s()", __func__);
|
|
|
|
stlc45xx_debug(DEBUG_TXBUFFER, "txbuffer: freed 0x%x-0x%x",
|
|
txbuffer->start, txbuffer->end);
|
|
|
|
list_del(&txbuffer->buffer_list);
|
|
kfree(txbuffer);
|
|
}
|
|
|
|
|
|
static int stlc45xx_wait_bit(struct stlc45xx *stlc, u16 reg, u32 mask,
|
|
u32 expected)
|
|
{
|
|
int i;
|
|
char buffer[4];
|
|
|
|
for (i = 0; i < 2000; i++) {
|
|
stlc45xx_spi_read(stlc, reg, buffer, sizeof(buffer));
|
|
if (((*(u32 *)buffer) & mask) == expected)
|
|
return 1;
|
|
msleep(1);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int stlc45xx_request_firmware(struct stlc45xx *stlc)
|
|
{
|
|
const struct firmware *fw;
|
|
int ret;
|
|
|
|
/* FIXME: should driver use it's own struct device? */
|
|
ret = request_firmware(&fw, "3826.arm", &stlc->spi->dev);
|
|
|
|
if (ret < 0) {
|
|
stlc45xx_error("request_firmware() failed: %d", ret);
|
|
return ret;
|
|
}
|
|
|
|
if (fw->size % 4) {
|
|
stlc45xx_error("firmware size is not multiple of 32bit: %zu",
|
|
fw->size);
|
|
return -EILSEQ; /* Illegal byte sequence */;
|
|
}
|
|
|
|
if (fw->size < 1000) {
|
|
stlc45xx_error("firmware is too small: %zu", fw->size);
|
|
return -EILSEQ;
|
|
}
|
|
|
|
stlc->fw = kmemdup(fw->data, fw->size, GFP_KERNEL);
|
|
if (!stlc->fw) {
|
|
stlc45xx_error("could not allocate memory for firmware");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
stlc->fw_len = fw->size;
|
|
|
|
release_firmware(fw);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int stlc45xx_upload_firmware(struct stlc45xx *stlc)
|
|
{
|
|
struct s_dma_regs dma_regs;
|
|
unsigned long fw_len, fw_addr;
|
|
long _fw_len;
|
|
int ret;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
if (!stlc->fw) {
|
|
ret = stlc45xx_request_firmware(stlc);
|
|
if (ret < 0)
|
|
return ret;
|
|
}
|
|
|
|
/* stop the device */
|
|
stlc45xx_write16(stlc, SPI_ADRS_DEV_CTRL_STAT,
|
|
SPI_CTRL_STAT_HOST_OVERRIDE | SPI_CTRL_STAT_HOST_RESET
|
|
| SPI_CTRL_STAT_START_HALTED);
|
|
|
|
msleep(TARGET_BOOT_SLEEP);
|
|
|
|
stlc45xx_write16(stlc, SPI_ADRS_DEV_CTRL_STAT,
|
|
SPI_CTRL_STAT_HOST_OVERRIDE
|
|
| SPI_CTRL_STAT_START_HALTED);
|
|
|
|
msleep(TARGET_BOOT_SLEEP);
|
|
|
|
fw_addr = FIRMWARE_ADDRESS;
|
|
fw_len = stlc->fw_len;
|
|
|
|
while (fw_len > 0) {
|
|
_fw_len = (fw_len > SPI_MAX_PACKET_SIZE)
|
|
? SPI_MAX_PACKET_SIZE : fw_len;
|
|
dma_regs.cmd = SPI_DMA_WRITE_CTRL_ENABLE;
|
|
dma_regs.len = cpu_to_le16(_fw_len);
|
|
dma_regs.addr = cpu_to_le32(fw_addr);
|
|
|
|
fw_len -= _fw_len;
|
|
fw_addr += _fw_len;
|
|
|
|
stlc45xx_write16(stlc, SPI_ADRS_DMA_WRITE_CTRL, dma_regs.cmd);
|
|
|
|
if (stlc45xx_wait_bit(stlc, SPI_ADRS_DMA_WRITE_CTRL,
|
|
HOST_ALLOWED, HOST_ALLOWED) == 0) {
|
|
stlc45xx_error("fw_upload not allowed to DMA write");
|
|
return -EAGAIN;
|
|
}
|
|
|
|
stlc45xx_write16(stlc, SPI_ADRS_DMA_WRITE_LEN, dma_regs.len);
|
|
stlc45xx_write32(stlc, SPI_ADRS_DMA_WRITE_BASE, dma_regs.addr);
|
|
|
|
stlc45xx_spi_write(stlc, SPI_ADRS_DMA_DATA, stlc->fw, _fw_len);
|
|
|
|
/* FIXME: I think this doesn't work if firmware is large,
|
|
* this loop goes to second round. fw->data is not
|
|
* increased at all! */
|
|
}
|
|
|
|
BUG_ON(fw_len != 0);
|
|
|
|
/* enable host interrupts */
|
|
stlc45xx_write32(stlc, SPI_ADRS_HOST_INT_EN, SPI_HOST_INTS_DEFAULT);
|
|
|
|
/* boot the device */
|
|
stlc45xx_write16(stlc, SPI_ADRS_DEV_CTRL_STAT,
|
|
SPI_CTRL_STAT_HOST_OVERRIDE | SPI_CTRL_STAT_HOST_RESET
|
|
| SPI_CTRL_STAT_RAM_BOOT);
|
|
|
|
msleep(TARGET_BOOT_SLEEP);
|
|
|
|
stlc45xx_write16(stlc, SPI_ADRS_DEV_CTRL_STAT,
|
|
SPI_CTRL_STAT_HOST_OVERRIDE | SPI_CTRL_STAT_RAM_BOOT);
|
|
msleep(TARGET_BOOT_SLEEP);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* caller must hold tx_lock */
|
|
static void stlc45xx_check_txsent(struct stlc45xx *stlc)
|
|
{
|
|
struct txbuffer *entry, *n;
|
|
|
|
list_for_each_entry_safe(entry, n, &stlc->tx_sent, tx_list) {
|
|
if (time_after(jiffies, entry->lifetime)) {
|
|
if (net_ratelimit())
|
|
stlc45xx_warning("frame 0x%x lifetime exceeded",
|
|
entry->start);
|
|
list_del(&entry->tx_list);
|
|
skb_pull(entry->skb, entry->header_len);
|
|
ieee80211_tx_status(stlc->hw, entry->skb);
|
|
stlc45xx_txbuffer_free(stlc, entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void stlc45xx_power_off(struct stlc45xx *stlc)
|
|
{
|
|
disable_irq(gpio_to_irq(stlc45xx_gpio_irq));
|
|
gpio_set_value(stlc45xx_gpio_power, 0);
|
|
}
|
|
|
|
static void stlc45xx_power_on(struct stlc45xx *stlc)
|
|
{
|
|
gpio_set_value(stlc45xx_gpio_power, 1);
|
|
enable_irq(gpio_to_irq(stlc45xx_gpio_irq));
|
|
|
|
/*
|
|
* need to wait a while before device can be accessed, the length
|
|
* is just a guess
|
|
*/
|
|
msleep(10);
|
|
}
|
|
|
|
/* caller must hold tx_lock */
|
|
static void stlc45xx_flush_queues(struct stlc45xx *stlc)
|
|
{
|
|
struct txbuffer *entry;
|
|
|
|
while (!list_empty(&stlc->tx_sent)) {
|
|
entry = list_first_entry(&stlc->tx_sent,
|
|
struct txbuffer, tx_list);
|
|
list_del(&entry->tx_list);
|
|
dev_kfree_skb(entry->skb);
|
|
stlc45xx_txbuffer_free(stlc, entry);
|
|
}
|
|
|
|
WARN_ON(!list_empty(&stlc->tx_sent));
|
|
|
|
while (!list_empty(&stlc->tx_pending)) {
|
|
entry = list_first_entry(&stlc->tx_pending,
|
|
struct txbuffer, tx_list);
|
|
list_del(&entry->tx_list);
|
|
dev_kfree_skb(entry->skb);
|
|
stlc45xx_txbuffer_free(stlc, entry);
|
|
}
|
|
|
|
WARN_ON(!list_empty(&stlc->tx_pending));
|
|
WARN_ON(!list_empty(&stlc->txbuffer));
|
|
}
|
|
|
|
static void stlc45xx_work_reset(struct work_struct *work)
|
|
{
|
|
struct stlc45xx *stlc = container_of(work, struct stlc45xx,
|
|
work_reset);
|
|
|
|
mutex_lock(&stlc->mutex);
|
|
|
|
if (stlc->fw_state != FW_STATE_RESET)
|
|
goto out;
|
|
|
|
stlc45xx_power_off(stlc);
|
|
|
|
mutex_unlock(&stlc->mutex);
|
|
|
|
/* wait that all work_structs have finished, we can't hold
|
|
* stlc->mutex to avoid deadlock */
|
|
cancel_work_sync(&stlc->work);
|
|
|
|
/* FIXME: find out good value to wait for chip power down */
|
|
msleep(100);
|
|
|
|
mutex_lock(&stlc->mutex);
|
|
|
|
/* FIXME: we should gracefully handle if the state has changed
|
|
* after re-acquiring mutex */
|
|
WARN_ON(stlc->fw_state != FW_STATE_RESET);
|
|
|
|
spin_lock_bh(&stlc->tx_lock);
|
|
stlc45xx_flush_queues(stlc);
|
|
spin_unlock_bh(&stlc->tx_lock);
|
|
|
|
stlc->fw_state = FW_STATE_RESETTING;
|
|
|
|
stlc45xx_power_on(stlc);
|
|
stlc45xx_upload_firmware(stlc);
|
|
|
|
out:
|
|
mutex_unlock(&stlc->mutex);
|
|
}
|
|
|
|
/* caller must hold mutex */
|
|
static void stlc45xx_reset(struct stlc45xx *stlc)
|
|
{
|
|
stlc45xx_warning("resetting firmware");
|
|
stlc->fw_state = FW_STATE_RESET;
|
|
ieee80211_stop_queues(stlc->hw);
|
|
queue_work(stlc->hw->workqueue, &stlc->work_reset);
|
|
}
|
|
|
|
static void stlc45xx_work_tx_timeout(struct work_struct *work)
|
|
{
|
|
struct stlc45xx *stlc = container_of(work, struct stlc45xx,
|
|
work_tx_timeout.work);
|
|
|
|
stlc45xx_warning("tx timeout");
|
|
|
|
mutex_lock(&stlc->mutex);
|
|
|
|
if (stlc->fw_state != FW_STATE_READY)
|
|
goto out;
|
|
|
|
stlc45xx_reset(stlc);
|
|
|
|
out:
|
|
mutex_unlock(&stlc->mutex);
|
|
}
|
|
|
|
static void stlc45xx_int_ack(struct stlc45xx *stlc, u32 val)
|
|
{
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
stlc45xx_write32(stlc, SPI_ADRS_HOST_INT_ACK, val);
|
|
}
|
|
|
|
static void stlc45xx_wakeup(struct stlc45xx *stlc)
|
|
{
|
|
unsigned long timeout;
|
|
u32 ints;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
/* wake the chip */
|
|
stlc45xx_write32(stlc, SPI_ADRS_ARM_INTERRUPTS, SPI_TARGET_INT_WAKEUP);
|
|
|
|
/* And wait for the READY interrupt */
|
|
timeout = jiffies + HZ;
|
|
|
|
ints = stlc45xx_read32(stlc, SPI_ADRS_HOST_INTERRUPTS);
|
|
while (!(ints & SPI_HOST_INT_READY)) {
|
|
if (time_after(jiffies, timeout))
|
|
goto out;
|
|
ints = stlc45xx_read32(stlc, SPI_ADRS_HOST_INTERRUPTS);
|
|
}
|
|
|
|
stlc45xx_int_ack(stlc, SPI_HOST_INT_READY);
|
|
|
|
out:
|
|
return;
|
|
}
|
|
|
|
static void stlc45xx_sleep(struct stlc45xx *stlc)
|
|
{
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
stlc45xx_write32(stlc, SPI_ADRS_ARM_INTERRUPTS, SPI_TARGET_INT_SLEEP);
|
|
}
|
|
|
|
static void stlc45xx_int_ready(struct stlc45xx *stlc)
|
|
{
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
stlc45xx_write32(stlc, SPI_ADRS_HOST_INT_EN,
|
|
SPI_HOST_INT_UPDATE | SPI_HOST_INT_SW_UPDATE);
|
|
|
|
switch (stlc->fw_state) {
|
|
case FW_STATE_BOOTING:
|
|
stlc->fw_state = FW_STATE_READY;
|
|
complete(&stlc->fw_comp);
|
|
break;
|
|
case FW_STATE_RESETTING:
|
|
stlc->fw_state = FW_STATE_READY;
|
|
|
|
stlc45xx_tx_scan(stlc);
|
|
stlc45xx_tx_setup(stlc);
|
|
stlc45xx_tx_edcf(stlc);
|
|
|
|
ieee80211_wake_queues(stlc->hw);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static int stlc45xx_rx_txack(struct stlc45xx *stlc, struct sk_buff *skb)
|
|
{
|
|
struct ieee80211_tx_info *info;
|
|
struct s_lm_control *control;
|
|
struct s_lmo_tx *tx;
|
|
struct txbuffer *entry;
|
|
int found = 0;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
control = (struct s_lm_control *) skb->data;
|
|
tx = (struct s_lmo_tx *) (control + 1);
|
|
|
|
if (list_empty(&stlc->tx_sent)) {
|
|
if (net_ratelimit())
|
|
stlc45xx_warning("no frames waiting for "
|
|
"acknowledgement");
|
|
return -1;
|
|
}
|
|
|
|
list_for_each_entry(entry, &stlc->tx_sent, tx_list) {
|
|
if (control->handle == entry->handle) {
|
|
found = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
if (net_ratelimit())
|
|
stlc45xx_warning("couldn't find frame for tx ack 0x%x",
|
|
control->handle);
|
|
return -1;
|
|
}
|
|
|
|
stlc45xx_debug(DEBUG_TX, "TX ACK 0x%x", entry->handle);
|
|
|
|
if (entry->status_needed) {
|
|
info = IEEE80211_SKB_CB(entry->skb);
|
|
|
|
if (!(tx->flags & LM_TX_FAILED)) {
|
|
/* frame was acked */
|
|
info->flags |= IEEE80211_TX_STAT_ACK;
|
|
info->status.ack_signal = tx->rcpi / 2 - 110;
|
|
}
|
|
|
|
skb_pull(entry->skb, entry->header_len);
|
|
|
|
ieee80211_tx_status(stlc->hw, entry->skb);
|
|
}
|
|
|
|
list_del(&entry->tx_list);
|
|
|
|
stlc45xx_check_txsent(stlc);
|
|
if (list_empty(&stlc->tx_sent))
|
|
/* there are no pending frames, we can stop the tx timeout
|
|
* timer */
|
|
cancel_delayed_work(&stlc->work_tx_timeout);
|
|
|
|
spin_lock_bh(&stlc->tx_lock);
|
|
|
|
stlc45xx_txbuffer_free(stlc, entry);
|
|
|
|
if (stlc->tx_queue_stopped &&
|
|
stlc45xx_txbuffer_find(stlc, MAX_FRAME_LEN) != -1) {
|
|
stlc45xx_debug(DEBUG_QUEUE, "room in tx buffer, waking queues");
|
|
ieee80211_wake_queues(stlc->hw);
|
|
stlc->tx_queue_stopped = 0;
|
|
}
|
|
|
|
spin_unlock_bh(&stlc->tx_lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int stlc45xx_rx_control(struct stlc45xx *stlc, struct sk_buff *skb)
|
|
{
|
|
struct s_lm_control *control;
|
|
int ret = 0;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
control = (struct s_lm_control *) skb->data;
|
|
|
|
switch (control->oid) {
|
|
case LM_OID_TX:
|
|
ret = stlc45xx_rx_txack(stlc, skb);
|
|
break;
|
|
case LM_OID_SETUP:
|
|
case LM_OID_SCAN:
|
|
case LM_OID_TRAP:
|
|
case LM_OID_EDCF:
|
|
case LM_OID_KEYCACHE:
|
|
case LM_OID_PSM:
|
|
case LM_OID_STATS:
|
|
case LM_OID_LED:
|
|
default:
|
|
stlc45xx_warning("unhandled rx control oid %d\n",
|
|
control->oid);
|
|
break;
|
|
}
|
|
|
|
dev_kfree_skb(skb);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* copied from mac80211 */
|
|
static void stlc45xx_parse_elems(u8 *start, size_t len,
|
|
struct stlc45xx_ie_tim **tim,
|
|
size_t *tim_len)
|
|
{
|
|
size_t left = len;
|
|
u8 *pos = start;
|
|
|
|
while (left >= 2) {
|
|
u8 id, elen;
|
|
|
|
id = *pos++;
|
|
elen = *pos++;
|
|
left -= 2;
|
|
|
|
if (elen > left)
|
|
return;
|
|
|
|
switch (id) {
|
|
case WLAN_EID_TIM:
|
|
*tim = (struct stlc45xx_ie_tim *) pos;
|
|
*tim_len = elen;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
left -= elen;
|
|
pos += elen;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* mac80211 doesn't have support for asking frames with PS-Poll, so let's
|
|
* implement in the driver for now. We have to add support to mac80211
|
|
* later.
|
|
*/
|
|
static int stlc45xx_check_more_data(struct stlc45xx *stlc, struct sk_buff *skb)
|
|
{
|
|
struct s_lm_data_in *data = (struct s_lm_data_in *) skb->data;
|
|
struct ieee80211_hdr *hdr;
|
|
size_t len;
|
|
u16 fc;
|
|
|
|
hdr = (void *) skb->data + sizeof(*data);
|
|
len = skb->len - sizeof(*data);
|
|
|
|
/* minimum frame length is the null frame length 24 bytes */
|
|
if (len < 24) {
|
|
stlc45xx_warning("invalid frame length when checking for "
|
|
"more data");
|
|
return -EINVAL;
|
|
}
|
|
|
|
fc = le16_to_cpu(hdr->frame_control);
|
|
if (!(fc & IEEE80211_FCTL_FROMDS))
|
|
/* this is not from DS */
|
|
return 0;
|
|
|
|
if (compare_ether_addr(hdr->addr1, stlc->mac_addr) != 0)
|
|
/* the frame was not for us */
|
|
return 0;
|
|
|
|
if (!(fc & IEEE80211_FCTL_MOREDATA)) {
|
|
/* AP has no more frames buffered for us */
|
|
stlc45xx_debug(DEBUG_PSM, "all buffered frames retrieved");
|
|
stlc->pspolling = false;
|
|
return 0;
|
|
}
|
|
|
|
/* MOREDATA bit is set, let's ask for a new frame from the AP */
|
|
stlc45xx_tx_pspoll(stlc, stlc->psm);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* mac80211 cannot read TIM from beacons, so let's add a hack to the
|
|
* driver. We have to add support to mac80211 later.
|
|
*/
|
|
static int stlc45xx_rx_data_beacon(struct stlc45xx *stlc, struct sk_buff *skb)
|
|
{
|
|
struct s_lm_data_in *data = (struct s_lm_data_in *) skb->data;
|
|
size_t len = skb->len, tim_len = 0, baselen, pvbmap_len;
|
|
struct ieee80211_mgmt *mgmt;
|
|
struct stlc45xx_ie_tim *tim = NULL;
|
|
int bmap_offset, index, aid_bit;
|
|
|
|
mgmt = (void *) skb->data + sizeof(*data);
|
|
|
|
baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt;
|
|
if (baselen > len) {
|
|
stlc45xx_warning("invalid baselen in beacon");
|
|
return -EINVAL;
|
|
}
|
|
|
|
stlc45xx_parse_elems(mgmt->u.beacon.variable, len - baselen, &tim,
|
|
&tim_len);
|
|
|
|
if (!tim) {
|
|
stlc45xx_warning("didn't find tim from a beacon");
|
|
return -EINVAL;
|
|
}
|
|
|
|
bmap_offset = tim->bmap_control & 0xfe;
|
|
index = stlc->aid / 8 - bmap_offset;
|
|
|
|
pvbmap_len = tim_len - 3;
|
|
if (index > pvbmap_len)
|
|
return -EINVAL;
|
|
|
|
aid_bit = !!(tim->pvbmap[index] & (1 << stlc->aid % 8));
|
|
|
|
stlc45xx_debug(DEBUG_PSM, "fc 0x%x duration %d seq %d dtim %u "
|
|
"bmap_control 0x%x aid_bit %d",
|
|
mgmt->frame_control, mgmt->duration, mgmt->seq_ctrl >> 4,
|
|
tim->dtim_count, tim->bmap_control, aid_bit);
|
|
|
|
if (!aid_bit)
|
|
return 0;
|
|
|
|
stlc->pspolling = true;
|
|
stlc45xx_tx_pspoll(stlc, stlc->psm);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int stlc45xx_rx_data(struct stlc45xx *stlc, struct sk_buff *skb)
|
|
{
|
|
struct ieee80211_rx_status status;
|
|
struct s_lm_data_in *data = (struct s_lm_data_in *) skb->data;
|
|
int align = 0;
|
|
u8 *p, align_len;
|
|
u16 len;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
if (stlc->psm) {
|
|
if (data->flags & LM_IN_BEACON)
|
|
stlc45xx_rx_data_beacon(stlc, skb);
|
|
else if (stlc->pspolling && (data->flags & LM_IN_DATA))
|
|
stlc45xx_check_more_data(stlc, skb);
|
|
}
|
|
|
|
memset(&status, 0, sizeof(status));
|
|
|
|
status.freq = data->frequency;
|
|
status.signal = data->rcpi / 2 - 110;
|
|
|
|
/* let's assume that maximum rcpi value is 140 (= 35 dBm) */
|
|
status.qual = data->rcpi * 100 / 140;
|
|
|
|
status.band = IEEE80211_BAND_2GHZ;
|
|
|
|
/*
|
|
* FIXME: this gives warning from __ieee80211_rx()
|
|
*
|
|
* status.rate_idx = data->rate;
|
|
*/
|
|
|
|
len = data->length;
|
|
|
|
if (data->flags & LM_FLAG_ALIGN)
|
|
align = 1;
|
|
|
|
skb_pull(skb, sizeof(*data));
|
|
|
|
if (align) {
|
|
p = skb->data;
|
|
align_len = *p;
|
|
skb_pull(skb, align_len);
|
|
}
|
|
|
|
skb_trim(skb, len);
|
|
|
|
stlc45xx_debug(DEBUG_RX, "rx data 0x%p %d B", skb->data, skb->len);
|
|
stlc45xx_dump(DEBUG_RX_CONTENT, skb->data, skb->len);
|
|
|
|
memcpy(IEEE80211_SKB_RXCB(skb), &status, sizeof(status));
|
|
ieee80211_rx(stlc->hw, skb);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
static int stlc45xx_rx(struct stlc45xx *stlc)
|
|
{
|
|
struct s_lm_control *control;
|
|
struct sk_buff *skb;
|
|
int ret;
|
|
u16 len;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
stlc45xx_wakeup(stlc);
|
|
|
|
/* dummy read to flush SPI DMA controller bug */
|
|
stlc45xx_read16(stlc, SPI_ADRS_GEN_PURP_1);
|
|
|
|
len = stlc45xx_read16(stlc, SPI_ADRS_DMA_DATA);
|
|
|
|
if (len == 0) {
|
|
stlc45xx_warning("rx request of zero bytes");
|
|
return 0;
|
|
}
|
|
|
|
skb = dev_alloc_skb(len);
|
|
if (!skb) {
|
|
stlc45xx_warning("could not alloc skb");
|
|
return 0;
|
|
}
|
|
|
|
stlc45xx_spi_read(stlc, SPI_ADRS_DMA_DATA, skb_put(skb, len), len);
|
|
|
|
stlc45xx_sleep(stlc);
|
|
|
|
stlc45xx_debug(DEBUG_RX, "rx frame 0x%p %d B", skb->data, skb->len);
|
|
stlc45xx_dump(DEBUG_RX_CONTENT, skb->data, skb->len);
|
|
|
|
control = (struct s_lm_control *) skb->data;
|
|
|
|
if (control->flags & LM_FLAG_CONTROL)
|
|
ret = stlc45xx_rx_control(stlc, skb);
|
|
else
|
|
ret = stlc45xx_rx_data(stlc, skb);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static irqreturn_t stlc45xx_interrupt(int irq, void *config)
|
|
{
|
|
struct spi_device *spi = config;
|
|
struct stlc45xx *stlc = dev_get_drvdata(&spi->dev);
|
|
|
|
stlc45xx_debug(DEBUG_IRQ, "IRQ");
|
|
|
|
queue_work(stlc->hw->workqueue, &stlc->work);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static int stlc45xx_tx_frame(struct stlc45xx *stlc, u32 address,
|
|
void *buf, size_t len)
|
|
{
|
|
struct s_dma_regs dma_regs;
|
|
unsigned long timeout;
|
|
int ret = 0;
|
|
u32 ints;
|
|
|
|
stlc->tx_frames++;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
stlc45xx_debug(DEBUG_TX, "tx frame 0x%p %zu B", buf, len);
|
|
stlc45xx_dump(DEBUG_TX_CONTENT, buf, len);
|
|
|
|
stlc45xx_wakeup(stlc);
|
|
|
|
dma_regs.cmd = SPI_DMA_WRITE_CTRL_ENABLE;
|
|
dma_regs.len = cpu_to_le16(len);
|
|
dma_regs.addr = cpu_to_le32(address);
|
|
|
|
stlc45xx_spi_write(stlc, SPI_ADRS_DMA_WRITE_CTRL, &dma_regs,
|
|
sizeof(dma_regs));
|
|
|
|
stlc45xx_spi_write(stlc, SPI_ADRS_DMA_DATA, buf, len);
|
|
|
|
timeout = jiffies + 2 * HZ;
|
|
ints = stlc45xx_read32(stlc, SPI_ADRS_HOST_INTERRUPTS);
|
|
while (!(ints & SPI_HOST_INT_WR_READY)) {
|
|
if (time_after(jiffies, timeout)) {
|
|
stlc45xx_warning("WR_READY timeout");
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
ints = stlc45xx_read32(stlc, SPI_ADRS_HOST_INTERRUPTS);
|
|
}
|
|
|
|
stlc45xx_int_ack(stlc, SPI_HOST_INT_WR_READY);
|
|
|
|
stlc45xx_sleep(stlc);
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
static int stlc45xx_wq_tx(struct stlc45xx *stlc)
|
|
{
|
|
struct txbuffer *entry;
|
|
int ret = 0;
|
|
|
|
spin_lock_bh(&stlc->tx_lock);
|
|
|
|
while (!list_empty(&stlc->tx_pending)) {
|
|
entry = list_entry(stlc->tx_pending.next,
|
|
struct txbuffer, tx_list);
|
|
|
|
list_del_init(&entry->tx_list);
|
|
|
|
spin_unlock_bh(&stlc->tx_lock);
|
|
|
|
ret = stlc45xx_tx_frame(stlc, entry->frame_start,
|
|
entry->skb->data, entry->skb->len);
|
|
|
|
spin_lock_bh(&stlc->tx_lock);
|
|
|
|
if (ret < 0) {
|
|
/* frame transfer to firmware buffer failed */
|
|
/* FIXME: report this to mac80211 */
|
|
dev_kfree_skb(entry->skb);
|
|
stlc45xx_txbuffer_free(stlc, entry);
|
|
goto out;
|
|
}
|
|
|
|
list_add(&entry->tx_list, &stlc->tx_sent);
|
|
queue_delayed_work(stlc->hw->workqueue,
|
|
&stlc->work_tx_timeout,
|
|
msecs_to_jiffies(TX_TIMEOUT));
|
|
}
|
|
|
|
out:
|
|
spin_unlock_bh(&stlc->tx_lock);
|
|
return ret;
|
|
}
|
|
|
|
static void stlc45xx_work(struct work_struct *work)
|
|
{
|
|
struct stlc45xx *stlc = container_of(work, struct stlc45xx, work);
|
|
u32 ints;
|
|
int ret;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
mutex_lock(&stlc->mutex);
|
|
|
|
if (stlc->fw_state == FW_STATE_OFF &&
|
|
stlc->fw_state == FW_STATE_RESET)
|
|
goto out;
|
|
|
|
ints = stlc45xx_read32(stlc, SPI_ADRS_HOST_INTERRUPTS);
|
|
stlc45xx_debug(DEBUG_BH, "begin host_ints 0x%08x", ints);
|
|
|
|
if (ints & SPI_HOST_INT_READY) {
|
|
stlc45xx_int_ready(stlc);
|
|
stlc45xx_int_ack(stlc, SPI_HOST_INT_READY);
|
|
}
|
|
|
|
if (stlc->fw_state != FW_STATE_READY)
|
|
goto out;
|
|
|
|
if (ints & SPI_HOST_INT_UPDATE) {
|
|
stlc45xx_int_ack(stlc, SPI_HOST_INT_UPDATE);
|
|
ret = stlc45xx_rx(stlc);
|
|
if (ret < 0) {
|
|
stlc45xx_reset(stlc);
|
|
goto out;
|
|
}
|
|
}
|
|
if (ints & SPI_HOST_INT_SW_UPDATE) {
|
|
stlc45xx_int_ack(stlc, SPI_HOST_INT_SW_UPDATE);
|
|
ret = stlc45xx_rx(stlc);
|
|
if (ret < 0) {
|
|
stlc45xx_reset(stlc);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
ret = stlc45xx_wq_tx(stlc);
|
|
if (ret < 0) {
|
|
stlc45xx_reset(stlc);
|
|
goto out;
|
|
}
|
|
|
|
ints = stlc45xx_read32(stlc, SPI_ADRS_HOST_INTERRUPTS);
|
|
stlc45xx_debug(DEBUG_BH, "end host_ints 0x%08x", ints);
|
|
|
|
out:
|
|
mutex_unlock(&stlc->mutex);
|
|
}
|
|
|
|
static void stlc45xx_tx_edcf(struct stlc45xx *stlc)
|
|
{
|
|
struct s_lm_control *control;
|
|
struct s_lmo_edcf *edcf;
|
|
size_t len, edcf_len;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
edcf_len = sizeof(*edcf);
|
|
len = sizeof(*control) + edcf_len;
|
|
control = kzalloc(len, GFP_KERNEL);
|
|
edcf = (struct s_lmo_edcf *) (control + 1);
|
|
|
|
control->flags = LM_FLAG_CONTROL | LM_CTRL_OPSET;
|
|
control->length = edcf_len;
|
|
control->oid = LM_OID_EDCF;
|
|
|
|
edcf->slottime = 0x14;
|
|
edcf->sifs = 10;
|
|
edcf->eofpad = 6;
|
|
edcf->maxburst = 1500;
|
|
|
|
edcf->queues[0].aifs = 2;
|
|
edcf->queues[0].pad0 = 1;
|
|
edcf->queues[0].cwmin = 3;
|
|
edcf->queues[0].cwmax = 7;
|
|
edcf->queues[0].txop = 47;
|
|
edcf->queues[1].aifs = 2;
|
|
edcf->queues[1].pad0 = 0;
|
|
edcf->queues[1].cwmin = 7;
|
|
edcf->queues[1].cwmax = 15;
|
|
edcf->queues[1].txop = 94;
|
|
edcf->queues[2].aifs = 3;
|
|
edcf->queues[2].pad0 = 0;
|
|
edcf->queues[2].cwmin = 15;
|
|
edcf->queues[2].cwmax = 1023;
|
|
edcf->queues[2].txop = 0;
|
|
edcf->queues[3].aifs = 7;
|
|
edcf->queues[3].pad0 = 0;
|
|
edcf->queues[3].cwmin = 15;
|
|
edcf->queues[3].cwmax = 1023;
|
|
edcf->queues[3].txop = 0;
|
|
edcf->queues[4].aifs = 13;
|
|
edcf->queues[4].pad0 = 99;
|
|
edcf->queues[4].cwmin = 3437;
|
|
edcf->queues[4].cwmax = 512;
|
|
edcf->queues[4].txop = 12;
|
|
edcf->queues[5].aifs = 142;
|
|
edcf->queues[5].pad0 = 109;
|
|
edcf->queues[5].cwmin = 8756;
|
|
edcf->queues[5].cwmax = 6;
|
|
edcf->queues[5].txop = 0;
|
|
edcf->queues[6].aifs = 4;
|
|
edcf->queues[6].pad0 = 0;
|
|
edcf->queues[6].cwmin = 0;
|
|
edcf->queues[6].cwmax = 58705;
|
|
edcf->queues[6].txop = 25716;
|
|
edcf->queues[7].aifs = 0;
|
|
edcf->queues[7].pad0 = 0;
|
|
edcf->queues[7].cwmin = 0;
|
|
edcf->queues[7].cwmax = 0;
|
|
edcf->queues[7].txop = 0;
|
|
|
|
stlc45xx_tx_frame(stlc, FIRMWARE_CONFIG_START, control, len);
|
|
|
|
kfree(control);
|
|
}
|
|
|
|
static void stlc45xx_tx_setup(struct stlc45xx *stlc)
|
|
{
|
|
struct s_lm_control *control;
|
|
struct s_lmo_setup *setup;
|
|
size_t len, setup_len;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
setup_len = sizeof(*setup);
|
|
len = sizeof(*control) + setup_len;
|
|
control = kzalloc(len, GFP_KERNEL);
|
|
setup = (struct s_lmo_setup *) (control + 1);
|
|
|
|
control->flags = LM_FLAG_CONTROL | LM_CTRL_OPSET;
|
|
control->length = setup_len;
|
|
control->oid = LM_OID_SETUP;
|
|
|
|
setup->flags = LM_SETUP_INFRA;
|
|
setup->antenna = 2;
|
|
setup->rx_align = 0;
|
|
setup->rx_buffer = FIRMWARE_RXBUFFER_START;
|
|
setup->rx_mtu = FIRMWARE_MTU;
|
|
setup->frontend = 5;
|
|
setup->timeout = 0;
|
|
setup->truncate = 48896;
|
|
setup->bratemask = 0xffffffff;
|
|
setup->ref_clock = 644245094;
|
|
setup->lpf_bandwidth = 65535;
|
|
setup->osc_start_delay = 65535;
|
|
|
|
memcpy(setup->macaddr, stlc->mac_addr, ETH_ALEN);
|
|
memcpy(setup->bssid, stlc->bssid, ETH_ALEN);
|
|
|
|
stlc45xx_tx_frame(stlc, FIRMWARE_CONFIG_START, control, len);
|
|
|
|
kfree(control);
|
|
}
|
|
|
|
static void stlc45xx_tx_scan(struct stlc45xx *stlc)
|
|
{
|
|
struct s_lm_control *control;
|
|
struct s_lmo_scan *scan;
|
|
size_t len, scan_len;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
scan_len = sizeof(*scan);
|
|
len = sizeof(*control) + scan_len;
|
|
control = kzalloc(len, GFP_KERNEL);
|
|
scan = (struct s_lmo_scan *) (control + 1);
|
|
|
|
control->flags = LM_FLAG_CONTROL | LM_CTRL_OPSET;
|
|
control->length = scan_len;
|
|
control->oid = LM_OID_SCAN;
|
|
|
|
scan->flags = LM_SCAN_EXIT;
|
|
scan->bratemask = 0x15f;
|
|
scan->aloft[0] = 3;
|
|
scan->aloft[1] = 3;
|
|
scan->aloft[2] = 1;
|
|
scan->aloft[3] = 0;
|
|
scan->aloft[4] = 0;
|
|
scan->aloft[5] = 0;
|
|
scan->aloft[6] = 0;
|
|
scan->aloft[7] = 0;
|
|
|
|
memcpy(&scan->rssical, &stlc->cal_rssi[(stlc->channel - 1) *
|
|
RSSI_CAL_LEN],
|
|
RSSI_CAL_LEN);
|
|
memcpy(&scan->channel, &stlc->cal_channels[(stlc->channel - 1) *
|
|
CHANNEL_CAL_LEN],
|
|
CHANNEL_CAL_LEN);
|
|
|
|
stlc45xx_tx_frame(stlc, FIRMWARE_CONFIG_START, control, len);
|
|
|
|
kfree(control);
|
|
}
|
|
|
|
/*
|
|
* caller must hold mutex
|
|
*/
|
|
static int stlc45xx_tx_pspoll(struct stlc45xx *stlc, bool powersave)
|
|
{
|
|
struct ieee80211_hdr *pspoll;
|
|
int payload_len, padding, i;
|
|
struct s_lm_data_out *data;
|
|
struct txbuffer *entry;
|
|
struct sk_buff *skb;
|
|
char *payload;
|
|
u16 fc;
|
|
|
|
skb = dev_alloc_skb(stlc->hw->extra_tx_headroom + 16);
|
|
if (!skb) {
|
|
stlc45xx_warning("failed to allocate pspoll frame");
|
|
return -ENOMEM;
|
|
}
|
|
skb_reserve(skb, stlc->hw->extra_tx_headroom);
|
|
|
|
pspoll = (struct ieee80211_hdr *) skb_put(skb, 16);
|
|
memset(pspoll, 0, 16);
|
|
fc = IEEE80211_FTYPE_CTL | IEEE80211_STYPE_PSPOLL;
|
|
if (powersave)
|
|
fc |= IEEE80211_FCTL_PM;
|
|
pspoll->frame_control = cpu_to_le16(fc);
|
|
pspoll->duration_id = cpu_to_le16(stlc->aid);
|
|
|
|
/* aid in PS-Poll has its two MSBs each set to 1 */
|
|
pspoll->duration_id |= cpu_to_le16(1 << 15) | cpu_to_le16(1 << 14);
|
|
|
|
memcpy(pspoll->addr1, stlc->bssid, ETH_ALEN);
|
|
memcpy(pspoll->addr2, stlc->mac_addr, ETH_ALEN);
|
|
|
|
stlc45xx_debug(DEBUG_PSM, "sending PS-Poll frame to %pM (powersave %d, "
|
|
"fc 0x%x, aid %d)", pspoll->addr1,
|
|
powersave, fc, stlc->aid);
|
|
|
|
spin_lock_bh(&stlc->tx_lock);
|
|
|
|
entry = stlc45xx_txbuffer_alloc(stlc, skb->len);
|
|
|
|
spin_unlock_bh(&stlc->tx_lock);
|
|
|
|
if (!entry) {
|
|
/*
|
|
* The queue should be stopped before the firmware buffer
|
|
* is full, so firmware buffer should always have enough
|
|
* space.
|
|
*
|
|
* But I'm too lazy and omit it for now.
|
|
*/
|
|
if (net_ratelimit())
|
|
stlc45xx_warning("firmware tx buffer full is full "
|
|
"for null frame");
|
|
return -ENOSPC;
|
|
}
|
|
|
|
payload = skb->data;
|
|
payload_len = skb->len;
|
|
padding = (int) (skb->data - sizeof(*data)) & 3;
|
|
entry->header_len = sizeof(*data) + padding;
|
|
|
|
entry->skb = skb;
|
|
entry->status_needed = false;
|
|
entry->handle = (u32) skb;
|
|
entry->lifetime = jiffies + msecs_to_jiffies(TX_FRAME_LIFETIME);
|
|
|
|
stlc45xx_debug(DEBUG_TX, "tx data 0x%x (0x%p payload %d B "
|
|
"padding %d header_len %d)",
|
|
entry->handle, payload, payload_len, padding,
|
|
entry->header_len);
|
|
stlc45xx_dump(DEBUG_TX_CONTENT, payload, payload_len);
|
|
|
|
data = (struct s_lm_data_out *) skb_push(skb, entry->header_len);
|
|
|
|
memset(data, 0, entry->header_len);
|
|
|
|
if (padding)
|
|
data->flags = LM_FLAG_ALIGN;
|
|
|
|
data->flags = LM_OUT_BURST;
|
|
data->length = payload_len;
|
|
data->handle = entry->handle;
|
|
data->aid = 1;
|
|
data->rts_retries = 7;
|
|
data->retries = 7;
|
|
data->aloft_ctrl = 0;
|
|
data->crypt_offset = 58;
|
|
data->keytype = 0;
|
|
data->keylen = 0;
|
|
data->queue = LM_QUEUE_DATA3;
|
|
data->backlog = 32;
|
|
data->antenna = 2;
|
|
data->cts = 3;
|
|
data->power = 127;
|
|
|
|
for (i = 0; i < 8; i++)
|
|
data->aloft[i] = 0;
|
|
|
|
/*
|
|
* check if there's enough space in tx buffer
|
|
*
|
|
* FIXME: ignored for now
|
|
*/
|
|
|
|
stlc45xx_tx_frame(stlc, entry->start, skb->data, skb->len);
|
|
|
|
list_add(&entry->tx_list, &stlc->tx_sent);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* caller must hold mutex
|
|
*
|
|
* shamelessly stolen from mac80211/ieee80211_send_nullfunc
|
|
*/
|
|
static int stlc45xx_tx_nullfunc(struct stlc45xx *stlc, bool powersave)
|
|
{
|
|
struct ieee80211_hdr *nullfunc;
|
|
int payload_len, padding, i;
|
|
struct s_lm_data_out *data;
|
|
struct txbuffer *entry;
|
|
struct sk_buff *skb;
|
|
char *payload;
|
|
u16 fc;
|
|
|
|
skb = dev_alloc_skb(stlc->hw->extra_tx_headroom + 24);
|
|
if (!skb) {
|
|
stlc45xx_warning("failed to allocate buffer for null frame\n");
|
|
return -ENOMEM;
|
|
}
|
|
skb_reserve(skb, stlc->hw->extra_tx_headroom);
|
|
|
|
nullfunc = (struct ieee80211_hdr *) skb_put(skb, 24);
|
|
memset(nullfunc, 0, 24);
|
|
fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |
|
|
IEEE80211_FCTL_TODS;
|
|
|
|
if (powersave)
|
|
fc |= IEEE80211_FCTL_PM;
|
|
|
|
nullfunc->frame_control = cpu_to_le16(fc);
|
|
memcpy(nullfunc->addr1, stlc->bssid, ETH_ALEN);
|
|
memcpy(nullfunc->addr2, stlc->mac_addr, ETH_ALEN);
|
|
memcpy(nullfunc->addr3, stlc->bssid, ETH_ALEN);
|
|
|
|
stlc45xx_debug(DEBUG_PSM, "sending Null frame to %pM (powersave %d, "
|
|
"fc 0x%x)", nullfunc->addr1, powersave, fc);
|
|
|
|
spin_lock_bh(&stlc->tx_lock);
|
|
|
|
entry = stlc45xx_txbuffer_alloc(stlc, skb->len);
|
|
|
|
spin_unlock_bh(&stlc->tx_lock);
|
|
|
|
if (!entry) {
|
|
/*
|
|
* The queue should be stopped before the firmware buffer
|
|
* is full, so firmware buffer should always have enough
|
|
* space.
|
|
*
|
|
* But I'm too lazy and omit it for now.
|
|
*/
|
|
if (net_ratelimit())
|
|
stlc45xx_warning("firmware tx buffer full is full "
|
|
"for null frame");
|
|
return -ENOSPC;
|
|
}
|
|
|
|
payload = skb->data;
|
|
payload_len = skb->len;
|
|
padding = (int) (skb->data - sizeof(*data)) & 3;
|
|
entry->header_len = sizeof(*data) + padding;
|
|
|
|
entry->skb = skb;
|
|
entry->status_needed = false;
|
|
entry->handle = (u32) skb;
|
|
entry->lifetime = jiffies + msecs_to_jiffies(TX_FRAME_LIFETIME);
|
|
|
|
stlc45xx_debug(DEBUG_TX, "tx data 0x%x (0x%p payload %d B "
|
|
"padding %d header_len %d)",
|
|
entry->handle, payload, payload_len, padding,
|
|
entry->header_len);
|
|
stlc45xx_dump(DEBUG_TX_CONTENT, payload, payload_len);
|
|
|
|
data = (struct s_lm_data_out *) skb_push(skb, entry->header_len);
|
|
|
|
memset(data, 0, entry->header_len);
|
|
|
|
if (padding)
|
|
data->flags = LM_FLAG_ALIGN;
|
|
|
|
data->flags = LM_OUT_BURST;
|
|
data->length = payload_len;
|
|
data->handle = entry->handle;
|
|
data->aid = 1;
|
|
data->rts_retries = 7;
|
|
data->retries = 7;
|
|
data->aloft_ctrl = 0;
|
|
data->crypt_offset = 58;
|
|
data->keytype = 0;
|
|
data->keylen = 0;
|
|
data->queue = LM_QUEUE_DATA3;
|
|
data->backlog = 32;
|
|
data->antenna = 2;
|
|
data->cts = 3;
|
|
data->power = 127;
|
|
|
|
for (i = 0; i < 8; i++)
|
|
data->aloft[i] = 0;
|
|
|
|
/*
|
|
* check if there's enough space in tx buffer
|
|
*
|
|
* FIXME: ignored for now
|
|
*/
|
|
|
|
stlc45xx_tx_frame(stlc, entry->start, skb->data, skb->len);
|
|
|
|
list_add(&entry->tx_list, &stlc->tx_sent);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* caller must hold mutex */
|
|
static void stlc45xx_tx_psm(struct stlc45xx *stlc, bool enable)
|
|
{
|
|
struct s_lm_control *control;
|
|
struct s_lmo_psm *psm;
|
|
size_t len, psm_len;
|
|
|
|
WARN_ON(!stlc->associated);
|
|
WARN_ON(stlc->aid < 1);
|
|
WARN_ON(stlc->aid > 2007);
|
|
|
|
psm_len = sizeof(*psm);
|
|
len = sizeof(*control) + psm_len;
|
|
control = kzalloc(len, GFP_KERNEL);
|
|
psm = (struct s_lmo_psm *) (control + 1);
|
|
|
|
control->flags = LM_FLAG_CONTROL | LM_CTRL_OPSET;
|
|
control->length = psm_len;
|
|
control->oid = LM_OID_PSM;
|
|
|
|
if (enable)
|
|
psm->flags |= LM_PSM;
|
|
|
|
psm->aid = stlc->aid;
|
|
|
|
psm->beacon_rcpi_skip_max = 60;
|
|
|
|
psm->intervals[0].interval = 1;
|
|
psm->intervals[0].periods = 1;
|
|
psm->intervals[1].interval = 1;
|
|
psm->intervals[1].periods = 1;
|
|
psm->intervals[2].interval = 1;
|
|
psm->intervals[2].periods = 1;
|
|
psm->intervals[3].interval = 1;
|
|
psm->intervals[3].periods = 1;
|
|
|
|
psm->nr = 0;
|
|
psm->exclude[0] = 0;
|
|
|
|
stlc45xx_debug(DEBUG_PSM, "sending LM_OID_PSM (aid %d, interval %d)",
|
|
psm->aid, psm->intervals[0].interval);
|
|
|
|
stlc45xx_tx_frame(stlc, FIRMWARE_CONFIG_START, control, len);
|
|
|
|
kfree(control);
|
|
}
|
|
|
|
static int stlc45xx_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
|
|
{
|
|
struct stlc45xx *stlc = hw->priv;
|
|
struct ieee80211_tx_info *info;
|
|
struct ieee80211_rate *rate;
|
|
int payload_len, padding, i;
|
|
struct s_lm_data_out *data;
|
|
struct txbuffer *entry;
|
|
char *payload;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
spin_lock_bh(&stlc->tx_lock);
|
|
|
|
entry = stlc45xx_txbuffer_alloc(stlc, skb->len);
|
|
if (!entry) {
|
|
/* the queue should be stopped before the firmware buffer
|
|
* is full, so firmware buffer should always have enough
|
|
* space */
|
|
if (net_ratelimit())
|
|
stlc45xx_warning("firmware buffer full");
|
|
spin_unlock_bh(&stlc->tx_lock);
|
|
return NETDEV_TX_BUSY;
|
|
}
|
|
|
|
info = IEEE80211_SKB_CB(skb);
|
|
|
|
payload = skb->data;
|
|
payload_len = skb->len;
|
|
padding = (int) (skb->data - sizeof(*data)) & 3;
|
|
entry->header_len = sizeof(*data) + padding;
|
|
|
|
entry->skb = skb;
|
|
entry->status_needed = true;
|
|
entry->handle = (u32) skb;
|
|
entry->lifetime = jiffies + msecs_to_jiffies(TX_FRAME_LIFETIME);
|
|
|
|
stlc45xx_debug(DEBUG_TX, "tx data 0x%x (0x%p payload %d B "
|
|
"padding %d header_len %d)",
|
|
entry->handle, payload, payload_len, padding,
|
|
entry->header_len);
|
|
stlc45xx_dump(DEBUG_TX_CONTENT, payload, payload_len);
|
|
|
|
data = (struct s_lm_data_out *) skb_push(skb, entry->header_len);
|
|
|
|
memset(data, 0, entry->header_len);
|
|
|
|
if (padding)
|
|
data->flags = LM_FLAG_ALIGN;
|
|
|
|
data->flags = LM_OUT_BURST;
|
|
data->length = payload_len;
|
|
data->handle = entry->handle;
|
|
data->aid = 1;
|
|
data->rts_retries = 7;
|
|
data->retries = 7;
|
|
data->aloft_ctrl = 0;
|
|
data->crypt_offset = 58;
|
|
data->keytype = 0;
|
|
data->keylen = 0;
|
|
data->queue = 2;
|
|
data->backlog = 32;
|
|
data->antenna = 2;
|
|
data->cts = 3;
|
|
data->power = 127;
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
rate = ieee80211_get_tx_rate(stlc->hw, info);
|
|
data->aloft[i] = rate->hw_value;
|
|
}
|
|
|
|
list_add_tail(&entry->tx_list, &stlc->tx_pending);
|
|
|
|
/* check if there's enough space in tx buffer */
|
|
if (stlc45xx_txbuffer_find(stlc, MAX_FRAME_LEN) == -1) {
|
|
stlc45xx_debug(DEBUG_QUEUE, "tx buffer full, stopping queues");
|
|
stlc->tx_queue_stopped = 1;
|
|
ieee80211_stop_queues(stlc->hw);
|
|
}
|
|
|
|
queue_work(stlc->hw->workqueue, &stlc->work);
|
|
|
|
spin_unlock_bh(&stlc->tx_lock);
|
|
|
|
return NETDEV_TX_OK;
|
|
}
|
|
|
|
static int stlc45xx_op_start(struct ieee80211_hw *hw)
|
|
{
|
|
struct stlc45xx *stlc = hw->priv;
|
|
unsigned long timeout;
|
|
int ret = 0;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
mutex_lock(&stlc->mutex);
|
|
|
|
stlc->fw_state = FW_STATE_BOOTING;
|
|
stlc->channel = 1;
|
|
|
|
stlc45xx_power_on(stlc);
|
|
|
|
ret = stlc45xx_upload_firmware(stlc);
|
|
if (ret < 0) {
|
|
stlc45xx_power_off(stlc);
|
|
goto out_unlock;
|
|
}
|
|
|
|
stlc->tx_queue_stopped = 0;
|
|
|
|
mutex_unlock(&stlc->mutex);
|
|
|
|
timeout = msecs_to_jiffies(2000);
|
|
timeout = wait_for_completion_interruptible_timeout(&stlc->fw_comp,
|
|
timeout);
|
|
if (!timeout) {
|
|
stlc45xx_error("firmware boot failed");
|
|
stlc45xx_power_off(stlc);
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
|
|
stlc45xx_debug(DEBUG_BOOT, "firmware booted");
|
|
|
|
/* FIXME: should we take mutex just after wait_for_completion()? */
|
|
mutex_lock(&stlc->mutex);
|
|
|
|
WARN_ON(stlc->fw_state != FW_STATE_READY);
|
|
|
|
out_unlock:
|
|
mutex_unlock(&stlc->mutex);
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
static void stlc45xx_op_stop(struct ieee80211_hw *hw)
|
|
{
|
|
struct stlc45xx *stlc = hw->priv;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
mutex_lock(&stlc->mutex);
|
|
|
|
WARN_ON(stlc->fw_state != FW_STATE_READY);
|
|
|
|
stlc45xx_power_off(stlc);
|
|
|
|
/* FIXME: make sure that all work_structs have completed */
|
|
|
|
spin_lock_bh(&stlc->tx_lock);
|
|
stlc45xx_flush_queues(stlc);
|
|
spin_unlock_bh(&stlc->tx_lock);
|
|
|
|
stlc->fw_state = FW_STATE_OFF;
|
|
|
|
mutex_unlock(&stlc->mutex);
|
|
}
|
|
|
|
static int stlc45xx_op_add_interface(struct ieee80211_hw *hw,
|
|
struct ieee80211_if_init_conf *conf)
|
|
{
|
|
struct stlc45xx *stlc = hw->priv;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
switch (conf->type) {
|
|
case NL80211_IFTYPE_STATION:
|
|
break;
|
|
default:
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
memcpy(stlc->mac_addr, conf->mac_addr, ETH_ALEN);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void stlc45xx_op_remove_interface(struct ieee80211_hw *hw,
|
|
struct ieee80211_if_init_conf *conf)
|
|
{
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
}
|
|
|
|
static int stlc45xx_op_config_interface(struct ieee80211_hw *hw,
|
|
struct ieee80211_vif *vif,
|
|
struct ieee80211_if_conf *conf)
|
|
{
|
|
struct stlc45xx *stlc = hw->priv;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
mutex_lock(&stlc->mutex);
|
|
|
|
memcpy(stlc->bssid, conf->bssid, ETH_ALEN);
|
|
stlc45xx_tx_setup(stlc);
|
|
|
|
mutex_unlock(&stlc->mutex);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int stlc45xx_op_config(struct ieee80211_hw *hw, u32 changed)
|
|
{
|
|
struct stlc45xx *stlc = hw->priv;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
mutex_lock(&stlc->mutex);
|
|
|
|
stlc->channel = hw->conf.channel->hw_value;
|
|
stlc45xx_tx_scan(stlc);
|
|
stlc45xx_tx_setup(stlc);
|
|
stlc45xx_tx_edcf(stlc);
|
|
|
|
if ((hw->conf.flags & IEEE80211_CONF_PS) != stlc->psm) {
|
|
stlc->psm = hw->conf.flags & IEEE80211_CONF_PS;
|
|
if (stlc->associated) {
|
|
stlc45xx_tx_psm(stlc, stlc->psm);
|
|
stlc45xx_tx_nullfunc(stlc, stlc->psm);
|
|
}
|
|
}
|
|
|
|
mutex_unlock(&stlc->mutex);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void stlc45xx_op_configure_filter(struct ieee80211_hw *hw,
|
|
unsigned int changed_flags,
|
|
unsigned int *total_flags,
|
|
int mc_count,
|
|
struct dev_addr_list *mc_list)
|
|
{
|
|
*total_flags = 0;
|
|
}
|
|
|
|
static void stlc45xx_op_bss_info_changed(struct ieee80211_hw *hw,
|
|
struct ieee80211_vif *vif,
|
|
struct ieee80211_bss_conf *info,
|
|
u32 changed)
|
|
{
|
|
struct stlc45xx *stlc = hw->priv;
|
|
|
|
if (changed & BSS_CHANGED_ASSOC) {
|
|
stlc->associated = info->assoc;
|
|
if (info->assoc)
|
|
stlc->aid = info->aid;
|
|
else
|
|
stlc->aid = -1;
|
|
|
|
if (stlc->psm) {
|
|
stlc45xx_tx_psm(stlc, stlc->psm);
|
|
stlc45xx_tx_nullfunc(stlc, stlc->psm);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* can't be const, mac80211 writes to this */
|
|
static struct ieee80211_rate stlc45xx_rates[] = {
|
|
{ .bitrate = 10, .hw_value = 0, .hw_value_short = 0, },
|
|
{ .bitrate = 20, .hw_value = 1, .hw_value_short = 1, },
|
|
{ .bitrate = 55, .hw_value = 2, .hw_value_short = 2, },
|
|
{ .bitrate = 110, .hw_value = 3, .hw_value_short = 3, },
|
|
{ .bitrate = 60, .hw_value = 4, .hw_value_short = 4, },
|
|
{ .bitrate = 90, .hw_value = 5, .hw_value_short = 5, },
|
|
{ .bitrate = 120, .hw_value = 6, .hw_value_short = 6, },
|
|
{ .bitrate = 180, .hw_value = 7, .hw_value_short = 7, },
|
|
{ .bitrate = 240, .hw_value = 8, .hw_value_short = 8, },
|
|
{ .bitrate = 360, .hw_value = 9, .hw_value_short = 9, },
|
|
{ .bitrate = 480, .hw_value = 10, .hw_value_short = 10, },
|
|
{ .bitrate = 540, .hw_value = 11, .hw_value_short = 11, },
|
|
};
|
|
|
|
/* can't be const, mac80211 writes to this */
|
|
static struct ieee80211_channel stlc45xx_channels[] = {
|
|
{ .hw_value = 1, .center_freq = 2412},
|
|
{ .hw_value = 2, .center_freq = 2417},
|
|
{ .hw_value = 3, .center_freq = 2422},
|
|
{ .hw_value = 4, .center_freq = 2427},
|
|
{ .hw_value = 5, .center_freq = 2432},
|
|
{ .hw_value = 6, .center_freq = 2437},
|
|
{ .hw_value = 7, .center_freq = 2442},
|
|
{ .hw_value = 8, .center_freq = 2447},
|
|
{ .hw_value = 9, .center_freq = 2452},
|
|
{ .hw_value = 10, .center_freq = 2457},
|
|
{ .hw_value = 11, .center_freq = 2462},
|
|
{ .hw_value = 12, .center_freq = 2467},
|
|
{ .hw_value = 13, .center_freq = 2472},
|
|
};
|
|
|
|
/* can't be const, mac80211 writes to this */
|
|
static struct ieee80211_supported_band stlc45xx_band_2ghz = {
|
|
.channels = stlc45xx_channels,
|
|
.n_channels = ARRAY_SIZE(stlc45xx_channels),
|
|
.bitrates = stlc45xx_rates,
|
|
.n_bitrates = ARRAY_SIZE(stlc45xx_rates),
|
|
};
|
|
|
|
static const struct ieee80211_ops stlc45xx_ops = {
|
|
.start = stlc45xx_op_start,
|
|
.stop = stlc45xx_op_stop,
|
|
.add_interface = stlc45xx_op_add_interface,
|
|
.remove_interface = stlc45xx_op_remove_interface,
|
|
.config = stlc45xx_op_config,
|
|
.config_interface = stlc45xx_op_config_interface,
|
|
.configure_filter = stlc45xx_op_configure_filter,
|
|
.tx = stlc45xx_op_tx,
|
|
.bss_info_changed = stlc45xx_op_bss_info_changed,
|
|
};
|
|
|
|
static int stlc45xx_register_mac80211(struct stlc45xx *stlc)
|
|
{
|
|
/* FIXME: SET_IEEE80211_PERM_ADDR() requires default_mac_addr
|
|
to be non-const for some strange reason */
|
|
static u8 default_mac_addr[ETH_ALEN] = {
|
|
0x00, 0x02, 0xee, 0xc0, 0xff, 0xee
|
|
};
|
|
int ret;
|
|
|
|
SET_IEEE80211_PERM_ADDR(stlc->hw, default_mac_addr);
|
|
|
|
ret = ieee80211_register_hw(stlc->hw);
|
|
if (ret) {
|
|
stlc45xx_error("unable to register mac80211 hw: %d", ret);
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void stlc45xx_device_release(struct device *dev)
|
|
{
|
|
|
|
}
|
|
|
|
static struct platform_device stlc45xx_device = {
|
|
.name = "stlc45xx",
|
|
.id = -1,
|
|
|
|
/* device model insists to have a release function */
|
|
.dev = {
|
|
.release = stlc45xx_device_release,
|
|
},
|
|
};
|
|
|
|
static int __devinit stlc45xx_probe(struct spi_device *spi)
|
|
{
|
|
struct stlc45xx *stlc;
|
|
struct ieee80211_hw *hw;
|
|
int ret;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
/* mac80211 alloc */
|
|
hw = ieee80211_alloc_hw(sizeof(*stlc), &stlc45xx_ops);
|
|
if (!hw) {
|
|
stlc45xx_error("could not alloc ieee80211_hw");
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
/* mac80211 clears hw->priv */
|
|
stlc = hw->priv;
|
|
|
|
stlc->hw = hw;
|
|
dev_set_drvdata(&spi->dev, stlc);
|
|
stlc->spi = spi;
|
|
|
|
spi->bits_per_word = 16;
|
|
spi->max_speed_hz = 24000000;
|
|
|
|
ret = spi_setup(spi);
|
|
if (ret < 0)
|
|
stlc45xx_error("spi_setup failed");
|
|
|
|
ret = gpio_request(stlc45xx_gpio_power, "stlc45xx power");
|
|
if (ret < 0) {
|
|
stlc45xx_error("power GPIO request failed: %d", ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = gpio_request(stlc45xx_gpio_irq, "stlc45xx irq");
|
|
if (ret < 0) {
|
|
stlc45xx_error("irq GPIO request failed: %d", ret);
|
|
goto out;
|
|
}
|
|
|
|
gpio_direction_output(stlc45xx_gpio_power, 0);
|
|
gpio_direction_input(stlc45xx_gpio_irq);
|
|
|
|
ret = request_irq(gpio_to_irq(stlc45xx_gpio_irq),
|
|
stlc45xx_interrupt, IRQF_DISABLED, "stlc45xx",
|
|
stlc->spi);
|
|
if (ret < 0)
|
|
/* FIXME: handle the error */
|
|
stlc45xx_error("request_irq() failed");
|
|
|
|
set_irq_type(gpio_to_irq(stlc45xx_gpio_irq),
|
|
IRQ_TYPE_EDGE_RISING);
|
|
|
|
disable_irq(gpio_to_irq(stlc45xx_gpio_irq));
|
|
|
|
ret = platform_device_register(&stlc45xx_device);
|
|
if (ret) {
|
|
stlc45xx_error("Couldn't register wlan_omap device.");
|
|
return ret;
|
|
}
|
|
dev_set_drvdata(&stlc45xx_device.dev, stlc);
|
|
|
|
INIT_WORK(&stlc->work, stlc45xx_work);
|
|
INIT_WORK(&stlc->work_reset, stlc45xx_work_reset);
|
|
INIT_DELAYED_WORK(&stlc->work_tx_timeout, stlc45xx_work_tx_timeout);
|
|
mutex_init(&stlc->mutex);
|
|
init_completion(&stlc->fw_comp);
|
|
spin_lock_init(&stlc->tx_lock);
|
|
INIT_LIST_HEAD(&stlc->txbuffer);
|
|
INIT_LIST_HEAD(&stlc->tx_pending);
|
|
INIT_LIST_HEAD(&stlc->tx_sent);
|
|
|
|
hw->flags = IEEE80211_HW_RX_INCLUDES_FCS |
|
|
IEEE80211_HW_SIGNAL_DBM |
|
|
IEEE80211_HW_NOISE_DBM;
|
|
/* four bytes for padding */
|
|
hw->extra_tx_headroom = sizeof(struct s_lm_data_out) + 4;
|
|
|
|
/* unit us */
|
|
hw->channel_change_time = 1000;
|
|
|
|
hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
|
|
hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &stlc45xx_band_2ghz;
|
|
|
|
SET_IEEE80211_DEV(hw, &spi->dev);
|
|
|
|
BUILD_BUG_ON(sizeof(default_cal_rssi) != RSSI_CAL_ARRAY_LEN);
|
|
BUILD_BUG_ON(sizeof(default_cal_channels) != CHANNEL_CAL_ARRAY_LEN);
|
|
|
|
stlc->cal_rssi = kmemdup(default_cal_rssi, RSSI_CAL_ARRAY_LEN,
|
|
GFP_KERNEL);
|
|
stlc->cal_channels = kmemdup(default_cal_channels,
|
|
CHANNEL_CAL_ARRAY_LEN,
|
|
GFP_KERNEL);
|
|
|
|
ret = device_create_file(&stlc45xx_device.dev, &dev_attr_cal_rssi);
|
|
if (ret < 0) {
|
|
stlc45xx_error("failed to create sysfs file cal_rssi");
|
|
goto out;
|
|
}
|
|
|
|
ret = device_create_file(&stlc45xx_device.dev, &dev_attr_cal_channels);
|
|
if (ret < 0) {
|
|
stlc45xx_error("failed to create sysfs file cal_channels");
|
|
goto out;
|
|
}
|
|
|
|
ret = device_create_file(&stlc45xx_device.dev, &dev_attr_tx_buf);
|
|
if (ret < 0) {
|
|
stlc45xx_error("failed to create sysfs file tx_buf");
|
|
goto out;
|
|
}
|
|
|
|
ret = stlc45xx_register_mac80211(stlc);
|
|
if (ret < 0)
|
|
goto out;
|
|
|
|
stlc45xx_info("v" DRIVER_VERSION " loaded");
|
|
|
|
stlc45xx_info("config buffer 0x%x-0x%x",
|
|
FIRMWARE_CONFIG_START, FIRMWARE_CONFIG_END);
|
|
stlc45xx_info("tx 0x%x-0x%x, rx 0x%x-0x%x",
|
|
FIRMWARE_TXBUFFER_START, FIRMWARE_TXBUFFER_END,
|
|
FIRMWARE_RXBUFFER_START, FIRMWARE_RXBUFFER_END);
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
static int __devexit stlc45xx_remove(struct spi_device *spi)
|
|
{
|
|
struct stlc45xx *stlc = dev_get_drvdata(&spi->dev);
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
platform_device_unregister(&stlc45xx_device);
|
|
|
|
ieee80211_unregister_hw(stlc->hw);
|
|
|
|
free_irq(gpio_to_irq(stlc45xx_gpio_irq), spi);
|
|
|
|
gpio_free(stlc45xx_gpio_power);
|
|
gpio_free(stlc45xx_gpio_irq);
|
|
|
|
/* FIXME: free cal_channels and cal_rssi? */
|
|
|
|
kfree(stlc->fw);
|
|
|
|
mutex_destroy(&stlc->mutex);
|
|
|
|
/* frees also stlc */
|
|
ieee80211_free_hw(stlc->hw);
|
|
stlc = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static struct spi_driver stlc45xx_spi_driver = {
|
|
.driver = {
|
|
/* use cx3110x name because board-n800.c uses that for the
|
|
* SPI port */
|
|
.name = "cx3110x",
|
|
.bus = &spi_bus_type,
|
|
.owner = THIS_MODULE,
|
|
},
|
|
|
|
.probe = stlc45xx_probe,
|
|
.remove = __devexit_p(stlc45xx_remove),
|
|
};
|
|
|
|
static int __init stlc45xx_init(void)
|
|
{
|
|
int ret;
|
|
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
ret = spi_register_driver(&stlc45xx_spi_driver);
|
|
if (ret < 0) {
|
|
stlc45xx_error("failed to register SPI driver: %d", ret);
|
|
goto out;
|
|
}
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
static void __exit stlc45xx_exit(void)
|
|
{
|
|
stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
|
|
|
|
spi_unregister_driver(&stlc45xx_spi_driver);
|
|
|
|
stlc45xx_info("unloaded");
|
|
}
|
|
|
|
module_init(stlc45xx_init);
|
|
module_exit(stlc45xx_exit);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR("Kalle Valo <kalle.valo@nokia.com>");
|