?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sky2: Fix checksum endianness
[linux-2.6/mini2440.git] / drivers / staging / stlc45xx / stlc45xx.c
blobcfdaac9b747edbc15cc3c0c0746772815b6ddd9c
1 /*
2 * This file is part of stlc45xx
3 *
4 * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).
5 *
6 * Contact: Kalle Valo <kalle.valo@nokia.com>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20 * 02110-1301 USA
21 *
22 */
23
24 #include "stlc45xx.h"
25
26 #include <linux/module.h>
27 #include <linux/platform_device.h>
28 #include <linux/interrupt.h>
29 #include <linux/firmware.h>
30 #include <linux/delay.h>
31 #include <linux/irq.h>
32 #include <linux/spi/spi.h>
33 #include <linux/etherdevice.h>
34 #include <linux/gpio.h>
35 #include <linux/moduleparam.h>
36
37 #include "stlc45xx_lmac.h"
38
39 /*
40 * gpios should be handled in board files and provided via platform data,
41 * but because it's currently impossible for stlc45xx to have a header file
42 * in include/linux, let's use module paramaters for now
43 */
44 static int stlc45xx_gpio_power = 97;
45 module_param(stlc45xx_gpio_power, int, 0444);
46 MODULE_PARM_DESC(stlc45xx_gpio_power, "stlc45xx gpio number for power line");
47
48 static int stlc45xx_gpio_irq = 87;
49 module_param(stlc45xx_gpio_irq, int, 0444);
50 MODULE_PARM_DESC(stlc45xx_gpio_irq, "stlc45xx gpio number for irq line");
51
52 static const u8 default_cal_channels[] = {
53 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
54 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x09,
55 0x00, 0x00, 0xc9, 0xff, 0xd8, 0xff, 0x00, 0x00, 0x00, 0x01, 0x10,
56 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0xe0, 0x00, 0xe0, 0x00,
57 0xe0, 0x00, 0xe0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0,
58 0x00, 0x54, 0x01, 0xab, 0xf6, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42,
59 0xc0, 0x42, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00,
60 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x22, 0x01, 0x37, 0xa9,
61 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0x00, 0xbc, 0x00,
62 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc,
63 0x00, 0xbc, 0xfb, 0x00, 0xca, 0x79, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0,
64 0x2b, 0xc0, 0x2b, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4,
65 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0xd0, 0x00, 0x5d,
66 0x54, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0x00, 0xaa,
67 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00,
68 0xaa, 0x00, 0xaa, 0xa7, 0x00, 0xa9, 0x3d, 0xc0, 0x17, 0xc0, 0x17,
69 0xc0, 0x17, 0xc0, 0x17, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00,
70 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x7a, 0x00,
71 0x06, 0x2c, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0x00,
72 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96,
73 0x00, 0x96, 0x00, 0x96, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
74 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
75 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
76 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
77 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
78 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
79 0x00, 0x00, 0x06, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
80 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
81 0x00, 0x00, 0x00, 0x00, 0x71, 0x09, 0x00, 0x00, 0xc9, 0xff, 0xd8,
82 0xff, 0x00, 0x00, 0x00, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01,
83 0x10, 0x01, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xd0,
84 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0x54, 0x01, 0xab, 0xf6,
85 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0x00, 0xcb, 0x00,
86 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb,
87 0x00, 0xcb, 0x22, 0x01, 0x37, 0xa9, 0xc0, 0x33, 0xc0, 0x33, 0xc0,
88 0x33, 0xc0, 0x33, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc,
89 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0xfb, 0x00, 0xca,
90 0x79, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0x00, 0xb4,
91 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00,
92 0xb4, 0x00, 0xb4, 0xd0, 0x00, 0x5d, 0x54, 0xc0, 0x21, 0xc0, 0x21,
93 0xc0, 0x21, 0xc0, 0x21, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00,
94 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0xa7, 0x00,
95 0xa9, 0x3d, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0x00,
96 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0,
97 0x00, 0xa0, 0x00, 0xa0, 0x7a, 0x00, 0x06, 0x2c, 0xc0, 0x0d, 0xc0,
98 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96,
99 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00,
100 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
101 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
102 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
103 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
104 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
105 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x80, 0x80,
106 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
107 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76,
108 0x09, 0x00, 0x00, 0xc9, 0xff, 0xd8, 0xff, 0x00, 0x00, 0x00, 0x01,
109 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0xf0, 0x00, 0xf0,
110 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00,
111 0xd0, 0x00, 0x54, 0x01, 0xab, 0xf6, 0xc0, 0x42, 0xc0, 0x42, 0xc0,
112 0x42, 0xc0, 0x42, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb,
113 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x22, 0x01, 0x37,
114 0xa9, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0x00, 0xbc,
115 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00,
116 0xbc, 0x00, 0xbc, 0xfb, 0x00, 0xca, 0x79, 0xc0, 0x2b, 0xc0, 0x2b,
117 0xc0, 0x2b, 0xc0, 0x2b, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00,
118 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0xd0, 0x00,
119 0x5d, 0x54, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0x00,
120 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa,
121 0x00, 0xaa, 0x00, 0xaa, 0xa7, 0x00, 0xa9, 0x3d, 0xc0, 0x17, 0xc0,
122 0x17, 0xc0, 0x17, 0xc0, 0x17, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0,
123 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x7a,
124 0x00, 0x06, 0x2c, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d,
125 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00,
126 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
127 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
128 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
129 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
130 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
131 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
132 0x00, 0x00, 0x00, 0x06, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
133 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
134 0x00, 0x00, 0x00, 0x00, 0x00, 0x7b, 0x09, 0x00, 0x00, 0xc9, 0xff,
135 0xd8, 0xff, 0x00, 0x00, 0x00, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10,
136 0x01, 0x10, 0x01, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00,
137 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0x54, 0x01, 0xab,
138 0xf6, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0x00, 0xcb,
139 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00,
140 0xcb, 0x00, 0xcb, 0x22, 0x01, 0x37, 0xa9, 0xc0, 0x33, 0xc0, 0x33,
141 0xc0, 0x33, 0xc0, 0x33, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00,
142 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0xfb, 0x00,
143 0xca, 0x79, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0x00,
144 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4,
145 0x00, 0xb4, 0x00, 0xb4, 0xd0, 0x00, 0x5d, 0x54, 0xc0, 0x21, 0xc0,
146 0x21, 0xc0, 0x21, 0xc0, 0x21, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa,
147 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0xa7,
148 0x00, 0xa9, 0x3d, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17,
149 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00,
150 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x7a, 0x00, 0x06, 0x2c, 0xc0, 0x0d,
151 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0x00, 0x96, 0x00, 0x96, 0x00,
152 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96,
153 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
154 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
155 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
156 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
157 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
158 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x80,
159 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
160 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
161 0x80, 0x09, 0x00, 0x00, 0xc9, 0xff, 0xd8, 0xff, 0x00, 0x00, 0x00,
162 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0xf0, 0x00,
163 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0,
164 0x00, 0xd0, 0x00, 0x54, 0x01, 0xab, 0xf6, 0xc0, 0x42, 0xc0, 0x42,
165 0xc0, 0x42, 0xc0, 0x42, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00,
166 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x22, 0x01,
167 0x37, 0xa9, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0x00,
168 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc,
169 0x00, 0xbc, 0x00, 0xbc, 0xfb, 0x00, 0xca, 0x79, 0xc0, 0x2b, 0xc0,
170 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4,
171 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0xd0,
172 0x00, 0x5d, 0x54, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21,
173 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00,
174 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0xa7, 0x00, 0xa9, 0x3d, 0xc0, 0x17,
175 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0x00, 0xa0, 0x00, 0xa0, 0x00,
176 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0,
177 0x7a, 0x00, 0x06, 0x2c, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0,
178 0x0d, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96,
179 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x00, 0x00, 0x00, 0x00,
180 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
181 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
182 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
183 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
184 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
185 0x00, 0x00, 0x00, 0x00, 0x06, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00,
186 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
187 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x85, 0x09, 0x00, 0x00, 0xc9,
188 0xff, 0xd8, 0xff, 0x00, 0x00, 0x00, 0x01, 0x10, 0x01, 0x10, 0x01,
189 0x10, 0x01, 0x10, 0x01, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xf0,
190 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0x54, 0x01,
191 0xab, 0xf6, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0x00,
192 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb,
193 0x00, 0xcb, 0x00, 0xcb, 0x22, 0x01, 0x37, 0xa9, 0xc0, 0x33, 0xc0,
194 0x33, 0xc0, 0x33, 0xc0, 0x33, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc,
195 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0xfb,
196 0x00, 0xca, 0x79, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b,
197 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00,
198 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0xd0, 0x00, 0x5d, 0x54, 0xc0, 0x21,
199 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0x00, 0xaa, 0x00, 0xaa, 0x00,
200 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa,
201 0xa7, 0x00, 0xa9, 0x3d, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0xc0,
202 0x17, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0,
203 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x7a, 0x00, 0x06, 0x2c, 0xc0,
204 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0x00, 0x96, 0x00, 0x96,
205 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00,
206 0x96, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
207 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
208 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
209 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
210 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
211 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
212 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
213 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
214 0x00, 0x8a, 0x09, 0x00, 0x00, 0xc9, 0xff, 0xd8, 0xff, 0x00, 0x00,
215 0x00, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0xf0,
216 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xd0, 0x00, 0xd0, 0x00,
217 0xd0, 0x00, 0xd0, 0x00, 0x54, 0x01, 0xab, 0xf6, 0xc0, 0x42, 0xc0,
218 0x42, 0xc0, 0x42, 0xc0, 0x42, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb,
219 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x22,
220 0x01, 0x37, 0xa9, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33,
221 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00,
222 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0xfb, 0x00, 0xca, 0x79, 0xc0, 0x2b,
223 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0x00, 0xb4, 0x00, 0xb4, 0x00,
224 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4,
225 0xd0, 0x00, 0x5d, 0x54, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0xc0,
226 0x21, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa,
227 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0xa7, 0x00, 0xa9, 0x3d, 0xc0,
228 0x17, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0x00, 0xa0, 0x00, 0xa0,
229 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00,
230 0xa0, 0x7a, 0x00, 0x06, 0x2c, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d,
231 0xc0, 0x0d, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00,
232 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x00, 0x00, 0x00,
233 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
234 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
235 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
236 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
237 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
238 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x80, 0x80, 0x00, 0x00, 0x00,
239 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
240 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8f, 0x09, 0x00, 0x00,
241 0xc9, 0xff, 0xd8, 0xff, 0x00, 0x00, 0x00, 0x01, 0x10, 0x01, 0x10,
242 0x01, 0x10, 0x01, 0x10, 0x01, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00,
243 0xf0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0x54,
244 0x01, 0xab, 0xf6, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42,
245 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00,
246 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x22, 0x01, 0x37, 0xa9, 0xc0, 0x33,
247 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0x00, 0xbc, 0x00, 0xbc, 0x00,
248 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc,
249 0xfb, 0x00, 0xca, 0x79, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0,
250 0x2b, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4,
251 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0xd0, 0x00, 0x5d, 0x54, 0xc0,
252 0x21, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0x00, 0xaa, 0x00, 0xaa,
253 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00,
254 0xaa, 0xa7, 0x00, 0xa9, 0x3d, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17,
255 0xc0, 0x17, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00,
256 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x7a, 0x00, 0x06, 0x2c,
257 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0x00, 0x96, 0x00,
258 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96,
259 0x00, 0x96, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
260 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
261 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
262 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
263 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
264 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
265 0x06, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
266 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
267 0x00, 0x00, 0x94, 0x09, 0x00, 0x00, 0xc9, 0xff, 0xd8, 0xff, 0x00,
268 0x00, 0x00, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01,
269 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xd0, 0x00, 0xd0,
270 0x00, 0xd0, 0x00, 0xd0, 0x00, 0x54, 0x01, 0xab, 0xf6, 0xc0, 0x42,
271 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0x00, 0xcb, 0x00, 0xcb, 0x00,
272 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb,
273 0x22, 0x01, 0x37, 0xa9, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0xc0,
274 0x33, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc,
275 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0xfb, 0x00, 0xca, 0x79, 0xc0,
276 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0x00, 0xb4, 0x00, 0xb4,
277 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00,
278 0xb4, 0xd0, 0x00, 0x5d, 0x54, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21,
279 0xc0, 0x21, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00,
280 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0xa7, 0x00, 0xa9, 0x3d,
281 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0x00, 0xa0, 0x00,
282 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0,
283 0x00, 0xa0, 0x7a, 0x00, 0x06, 0x2c, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0,
284 0x0d, 0xc0, 0x0d, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96,
285 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x00, 0x00,
286 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
287 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
288 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
289 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
290 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
291 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x80, 0x80, 0x00, 0x00,
292 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
293 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x99, 0x09, 0x00,
294 0x00, 0xc9, 0xff, 0xd8, 0xff, 0x00, 0x00, 0x00, 0x01, 0x10, 0x01,
295 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0xf0, 0x00, 0xf0, 0x00, 0xf0,
296 0x00, 0xf0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00,
297 0x54, 0x01, 0xab, 0xf6, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0xc0,
298 0x42, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb,
299 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x22, 0x01, 0x37, 0xa9, 0xc0,
300 0x33, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33, 0x00, 0xbc, 0x00, 0xbc,
301 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00,
302 0xbc, 0xfb, 0x00, 0xca, 0x79, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b,
303 0xc0, 0x2b, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00,
304 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0xd0, 0x00, 0x5d, 0x54,
305 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0xc0, 0x21, 0x00, 0xaa, 0x00,
306 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa,
307 0x00, 0xaa, 0xa7, 0x00, 0xa9, 0x3d, 0xc0, 0x17, 0xc0, 0x17, 0xc0,
308 0x17, 0xc0, 0x17, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0,
309 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x7a, 0x00, 0x06,
310 0x2c, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0xc0, 0x0d, 0x00, 0x96,
311 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00,
312 0x96, 0x00, 0x96, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x06, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x9e, 0x09, 0x00, 0x00, 0xc9, 0xff, 0xd8, 0xff,
321 0x00, 0x00, 0x00, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10,
322 0x01, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xd0, 0x00,
323 0xd0, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0x54, 0x01, 0xab, 0xf6, 0xc0,
324 0x42, 0xc0, 0x42, 0xc0, 0x42, 0xc0, 0x42, 0x00, 0xcb, 0x00, 0xcb,
325 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0xcb, 0x00,
326 0xcb, 0x22, 0x01, 0x37, 0xa9, 0xc0, 0x33, 0xc0, 0x33, 0xc0, 0x33,
327 0xc0, 0x33, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00,
328 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0x00, 0xbc, 0xfb, 0x00, 0xca, 0x79,
329 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0xc0, 0x2b, 0x00, 0xb4, 0x00,
330 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4, 0x00, 0xb4,
331 0x00, 0xb4, 0xd0, 0x00, 0x5d, 0x54, 0xc0, 0x21, 0xc0, 0x21, 0xc0,
332 0x21, 0xc0, 0x21, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa,
333 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xaa, 0xa7, 0x00, 0xa9,
334 0x3d, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0xc0, 0x17, 0x00, 0xa0,
335 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00,
336 0xa0, 0x00, 0xa0, 0x7a, 0x00, 0x06, 0x2c, 0xc0, 0x0d, 0xc0, 0x0d,
337 0xc0, 0x0d, 0xc0, 0x0d, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00,
338 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x96, 0x00, 0x00,
339 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
340 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
341 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
342 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
343 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x80, 0x80, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
346 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
347 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
349 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
360 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
361 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
362 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
363 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
364 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
365 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
366 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
367 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
368 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
369 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
370 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
371 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
372 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
373 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
374 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
375 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
376 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
377 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
378 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
379 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
380 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
381 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
382 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
383 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
384 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
385 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
386 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
387 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
388 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
389 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
390 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
391 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
392 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
393 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
394 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
395 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
396 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
397 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
398 0x00 };
399
400 static const u8 default_cal_rssi[] = {
401 0x0a, 0x01, 0x72, 0xfe, 0x1a, 0x00, 0x00, 0x00, 0x0a, 0x01, 0x72,
402 0xfe, 0x1a, 0x00, 0x00, 0x00, 0x0a, 0x01, 0x72, 0xfe, 0x1a, 0x00,
403 0x00, 0x00, 0x0a, 0x01, 0x72, 0xfe, 0x1a, 0x00, 0x00, 0x00, 0x0a,
404 0x01, 0x72, 0xfe, 0x1a, 0x00, 0x00, 0x00, 0x0a, 0x01, 0x72, 0xfe,
405 0x1a, 0x00, 0x00, 0x00, 0x0a, 0x01, 0x72, 0xfe, 0x1a, 0x00, 0x00,
406 0x00, 0x0a, 0x01, 0x72, 0xfe, 0x1a, 0x00, 0x00, 0x00, 0x0a, 0x01,
407 0x72, 0xfe, 0x1a, 0x00, 0x00, 0x00, 0x0a, 0x01, 0x72, 0xfe, 0x1a,
408 0x00, 0x00, 0x00, 0x0a, 0x01, 0x72, 0xfe, 0x1a, 0x00, 0x00, 0x00,
409 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
410 0x00, 0x00, 0x00, 0x00, 0x00 };
411
412 static void stlc45xx_tx_edcf(struct stlc45xx *stlc);
413 static void stlc45xx_tx_setup(struct stlc45xx *stlc);
414 static void stlc45xx_tx_scan(struct stlc45xx *stlc);
415 static void stlc45xx_tx_psm(struct stlc45xx *stlc, bool enable);
416 static int stlc45xx_tx_nullfunc(struct stlc45xx *stlc, bool powersave);
417 static int stlc45xx_tx_pspoll(struct stlc45xx *stlc, bool powersave);
418
419 static ssize_t stlc45xx_sysfs_show_cal_rssi(struct device *dev,
420 struct device_attribute *attr,
421 char *buf)
422 {
423 struct stlc45xx *stlc = dev_get_drvdata(dev);
424 ssize_t len;
425
426 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
427
428 len = PAGE_SIZE;
429
430 mutex_lock(&stlc->mutex);
431
432 if (stlc->cal_rssi)
433 hex_dump_to_buffer(stlc->cal_rssi, RSSI_CAL_ARRAY_LEN, 16,
434 2, buf, len, 0);
435 mutex_unlock(&stlc->mutex);
436
437 len = strlen(buf);
438
439 return len;
440 }
441
442 static ssize_t stlc45xx_sysfs_store_cal_rssi(struct device *dev,
443 struct device_attribute *attr,
444 const char *buf, size_t count)
445 {
446 struct stlc45xx *stlc = dev_get_drvdata(dev);
447
448 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
449
450 mutex_lock(&stlc->mutex);
451
452 if (count != RSSI_CAL_ARRAY_LEN) {
453 stlc45xx_error("invalid cal_rssi length: %zu", count);
454 count = 0;
455 goto out_unlock;
456 }
457
458 kfree(stlc->cal_rssi);
459
460 stlc->cal_rssi = kmemdup(buf, RSSI_CAL_ARRAY_LEN, GFP_KERNEL);
461
462 if (!stlc->cal_rssi) {
463 stlc45xx_error("failed to allocate memory for cal_rssi");
464 count = 0;
465 goto out_unlock;
466 }
467
468 out_unlock:
469 mutex_unlock(&stlc->mutex);
470
471 return count;
472 }
473
474 static ssize_t stlc45xx_sysfs_show_cal_channels(struct device *dev,
475 struct device_attribute *attr,
476 char *buf)
477 {
478 struct stlc45xx *stlc = dev_get_drvdata(dev);
479 ssize_t len;
480
481 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
482
483 len = PAGE_SIZE;
484
485 mutex_lock(&stlc->mutex);
486
487 if (stlc->cal_channels)
488 hex_dump_to_buffer(stlc->cal_channels, CHANNEL_CAL_ARRAY_LEN,
489 16, 2, buf, len, 0);
490
491 mutex_unlock(&stlc->mutex);
492
493 len = strlen(buf);
494
495 return len;
496 }
497
498 static ssize_t stlc45xx_sysfs_store_cal_channels(struct device *dev,
499 struct device_attribute *attr,
500 const char *buf, size_t count)
501 {
502 struct stlc45xx *stlc = dev_get_drvdata(dev);
503
504 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
505
506 mutex_lock(&stlc->mutex);
507
508 if (count != CHANNEL_CAL_ARRAY_LEN) {
509 stlc45xx_error("invalid cal_channels size: %zu ", count);
510 count = 0;
511 goto out_unlock;
512 }
513
514 kfree(stlc->cal_channels);
515
516 stlc->cal_channels = kmemdup(buf, count, GFP_KERNEL);
517
518 if (!stlc->cal_channels) {
519 stlc45xx_error("failed to allocate memory for cal_channels");
520 count = 0;
521 goto out_unlock;
522 }
523
524 out_unlock:
525 mutex_unlock(&stlc->mutex);
526
527 return count;
528 }
529
530 static ssize_t stlc45xx_sysfs_show_tx_buf(struct device *dev,
531 struct device_attribute *attr,
532 char *buf)
533 {
534 struct stlc45xx *stlc = dev_get_drvdata(dev);
535 struct txbuffer *entry;
536 ssize_t len = 0;
537
538 stlc45xx_debug(DEBUG_FUNC, "%s()", __func__);
539
540 mutex_lock(&stlc->mutex);
541
542 list_for_each_entry(entry, &stlc->tx_sent, tx_list) {
543 len += sprintf(buf + len, "0x%x: 0x%x-0x%x\n",
544 entry->handle, entry->start,
545 entry->end);
546 }
547
548 mutex_unlock(&stlc->mutex);
549
550 return len;
551 }
552
553 static DEVICE_ATTR(cal_rssi, S_IRUGO | S_IWUSR,
554 stlc45xx_sysfs_show_cal_rssi,
555 stlc45xx_sysfs_store_cal_rssi);
556 static DEVICE_ATTR(cal_channels, S_IRUGO | S_IWUSR,
557 stlc45xx_sysfs_show_cal_channels,
558 stlc45xx_sysfs_store_cal_channels);
559 static DEVICE_ATTR(tx_buf, S_IRUGO, stlc45xx_sysfs_show_tx_buf, NULL);
560
561 static void stlc45xx_spi_read(struct stlc45xx *stlc, unsigned long addr,
562 void *buf, size_t len)
563 {
564 struct spi_transfer t[2];
565 struct spi_message m;
566
567 /* We first push the address */
568 addr = (addr << 8) | ADDR_READ_BIT_15;
569
570 spi_message_init(&m);
571 memset(t, 0, sizeof(t));
572
573 t[0].tx_buf = &addr;
574 t[0].len = 2;
575 spi_message_add_tail(&t[0], &m);
576
577 t[1].rx_buf = buf;
578 t[1].len = len;
579 spi_message_add_tail(&t[1], &m);
580
581 spi_sync(stlc->spi, &m);
582 }
583
584
585 static void stlc45xx_spi_write(struct stlc45xx *stlc, unsigned long addr,
586 void *buf, size_t len)
587 {
588 struct spi_transfer t[3];
589 struct spi_message m;
590 u16 last_word;
591
592 /* We first push the address */
593 addr = addr << 8;
594
595 spi_message_init(&m);
596 memset(t, 0, sizeof(t));
597
598 t[0].tx_buf = &addr;
599 t[0].len = 2;
600 spi_message_add_tail(&t[0], &m);
601
602 t[1].tx_buf = buf;
603 t[1].len = len;
604 spi_message_add_tail(&t[1], &m);
605
606 if (len % 2) {
607 last_word = ((u8 *)buf)[len - 1];
608
609 t[2].tx_buf = &last_word;
610 t[2].len = 2;
611 spi_message_add_tail(&t[2], &m);
612 }
613
614 spi_sync(stlc->spi, &m);
615 }
616
617 static u16 stlc45xx_read16(struct stlc45xx *stlc, unsigned long addr)
618 {
619 u16 val;
620
621 stlc45xx_spi_read(stlc, addr, &val, sizeof(val));
622
623 return val;
624 }
625
626 static u32 stlc45xx_read32(struct stlc45xx *stlc, unsigned long addr)
627 {
628 u32 val;
629
630 stlc45xx_spi_read(stlc, addr, &val, sizeof(val));
631
632 return val;
633 }
634
635 static void stlc45xx_write16(struct stlc45xx *stlc, unsigned long addr, u16 val)
636 {
637 stlc45xx_spi_write(stlc, addr, &val, sizeof(val));
638 }
639
640 static void stlc45xx_write32(struct stlc45xx *stlc, unsigned long addr, u32 val)
641 {
642 stlc45xx_spi_write(stlc, addr, &val, sizeof(val));
643 }
644
645 struct stlc45xx_spi_reg {
646 u16 address;
647 u16 length;
648 char *name;
649 };
650
651 /* caller must hold tx_lock */
652 static void stlc45xx_txbuffer_dump(struct stlc45xx *stlc)
653 {
654 struct txbuffer *txbuffer;
655 char *buf, *pos;
656 int buf_len, l, count;
657
658 if (!(DEBUG_LEVEL & DEBUG_TXBUFFER))
659 return;
660
661 stlc45xx_debug(DEBUG_FUNC, "%s()", __func__);
662
663 buf_len = 500;
664 buf = kmalloc(buf_len, GFP_ATOMIC);
665 if (!buf)
666 return;
667
668 pos = buf;
669 count = 0;
670
671 list_for_each_entry(txbuffer, &stlc->txbuffer, buffer_list) {
672 l = snprintf(pos, buf_len, "0x%x-0x%x,",
673 txbuffer->start, txbuffer->end);
674 /* drop the null byte */
675 pos += l;
676 buf_len -= l;
677 count++;
678 }
679
680 if (count == 0)
681 *pos = '\0';
682 else
683 *--pos = '\0';
684
685 stlc45xx_debug(DEBUG_TXBUFFER, "txbuffer: in buffer %d regions: %s",
686 count, buf);
687
688 kfree(buf);
689 }
690
691 /* caller must hold tx_lock */
692 static int stlc45xx_txbuffer_find(struct stlc45xx *stlc, size_t len)
693 {
694 struct txbuffer *txbuffer;
695 int pos;
696
697 stlc45xx_debug(DEBUG_FUNC, "%s()", __func__);
698
699 pos = FIRMWARE_TXBUFFER_START;
700
701 if (list_empty(&stlc->txbuffer))
702 goto out;
703
704 /*
705 * the entries in txbuffer must be in the same order as they are in
706 * the real buffer
707 */
708 list_for_each_entry(txbuffer, &stlc->txbuffer, buffer_list) {
709 if (pos + len < txbuffer->start)
710 break;
711 pos = ALIGN(txbuffer->end + 1, 4);
712 }
713
714 if (pos + len > FIRMWARE_TXBUFFER_END)
715 /* not enough room */
716 pos = -1;
717
718 stlc45xx_debug(DEBUG_TXBUFFER, "txbuffer: find %zu B: 0x%x", len, pos);
719
720 out:
721 return pos;
722 }
723
724 static int stlc45xx_txbuffer_add(struct stlc45xx *stlc,
725 struct txbuffer *txbuffer)
726 {
727 struct txbuffer *r, *prev = NULL;
728
729 if (list_empty(&stlc->txbuffer)) {
730 list_add(&txbuffer->buffer_list, &stlc->txbuffer);
731 return 0;
732 }
733
734 r = list_first_entry(&stlc->txbuffer, struct txbuffer, buffer_list);
735
736 if (txbuffer->start < r->start) {
737 /* add to the beginning of the list */
738 list_add(&txbuffer->buffer_list, &stlc->txbuffer);
739 return 0;
740 }
741
742 prev = NULL;
743 list_for_each_entry(r, &stlc->txbuffer, buffer_list) {
744 /* skip first entry, we checked for that above */
745 if (!prev) {
746 prev = r;
747 continue;
748 }
749
750 /* double-check overlaps */
751 WARN_ON_ONCE(txbuffer->start >= r->start &&
752 txbuffer->start <= r->end);
753 WARN_ON_ONCE(txbuffer->end >= r->start &&
754 txbuffer->end <= r->end);
755
756 if (prev->end < txbuffer->start &&
757 txbuffer->end < r->start) {
758 /* insert at this spot */
759 list_add_tail(&txbuffer->buffer_list, &r->buffer_list);
760 return 0;
761 }
762
763 prev = r;
764 }
765
766 /* not found */
767 list_add_tail(&txbuffer->buffer_list, &stlc->txbuffer);
768
769 return 0;
770
771 }
772
773 /* caller must hold tx_lock */
774 static struct txbuffer *stlc45xx_txbuffer_alloc(struct stlc45xx *stlc,
775 size_t frame_len)
776 {
777 struct txbuffer *entry = NULL;
778 size_t len;
779 int pos;
780
781 stlc45xx_debug(DEBUG_FUNC, "%s()", __func__);
782
783 len = FIRMWARE_TXBUFFER_HEADER + frame_len + FIRMWARE_TXBUFFER_TRAILER;
784 pos = stlc45xx_txbuffer_find(stlc, len);
785
786 if (pos < 0)
787 return NULL;
788
789 WARN_ON_ONCE(pos + len > FIRMWARE_TXBUFFER_END);
790 WARN_ON_ONCE(pos < FIRMWARE_TXBUFFER_START);
791
792 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
793 entry->start = pos;
794 entry->frame_start = pos + FIRMWARE_TXBUFFER_HEADER;
795 entry->end = entry->start + len - 1;
796
797 stlc45xx_debug(DEBUG_TXBUFFER, "txbuffer: allocated 0x%x-0x%x",
798 entry->start, entry->end);
799
800 stlc45xx_txbuffer_add(stlc, entry);
801
802 stlc45xx_txbuffer_dump(stlc);
803
804 return entry;
805 }
806
807 /* caller must hold tx_lock */
808 static void stlc45xx_txbuffer_free(struct stlc45xx *stlc,
809 struct txbuffer *txbuffer)
810 {
811 stlc45xx_debug(DEBUG_FUNC, "%s()", __func__);
812
813 stlc45xx_debug(DEBUG_TXBUFFER, "txbuffer: freed 0x%x-0x%x",
814 txbuffer->start, txbuffer->end);
815
816 list_del(&txbuffer->buffer_list);
817 kfree(txbuffer);
818 }
819
820
821 static int stlc45xx_wait_bit(struct stlc45xx *stlc, u16 reg, u32 mask,
822 u32 expected)
823 {
824 int i;
825 char buffer[4];
826
827 for (i = 0; i < 2000; i++) {
828 stlc45xx_spi_read(stlc, reg, buffer, sizeof(buffer));
829 if (((*(u32 *)buffer) & mask) == expected)
830 return 1;
831 msleep(1);
832 }
833
834 return 0;
835 }
836
837 static int stlc45xx_request_firmware(struct stlc45xx *stlc)
838 {
839 const struct firmware *fw;
840 int ret;
841
842 /* FIXME: should driver use it's own struct device? */
843 ret = request_firmware(&fw, "3826.arm", &stlc->spi->dev);
844
845 if (ret < 0) {
846 stlc45xx_error("request_firmware() failed: %d", ret);
847 return ret;
848 }
849
850 if (fw->size % 4) {
851 stlc45xx_error("firmware size is not multiple of 32bit: %zu",
852 fw->size);
853 return -EILSEQ; /* Illegal byte sequence */;
854 }
855
856 if (fw->size < 1000) {
857 stlc45xx_error("firmware is too small: %zu", fw->size);
858 return -EILSEQ;
859 }
860
861 stlc->fw = kmemdup(fw->data, fw->size, GFP_KERNEL);
862 if (!stlc->fw) {
863 stlc45xx_error("could not allocate memory for firmware");
864 return -ENOMEM;
865 }
866
867 stlc->fw_len = fw->size;
868
869 release_firmware(fw);
870
871 return 0;
872 }
873
874 static int stlc45xx_upload_firmware(struct stlc45xx *stlc)
875 {
876 struct s_dma_regs dma_regs;
877 unsigned long fw_len, fw_addr;
878 long _fw_len;
879 int ret;
880
881 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
882
883 if (!stlc->fw) {
884 ret = stlc45xx_request_firmware(stlc);
885 if (ret < 0)
886 return ret;
887 }
888
889 /* stop the device */
890 stlc45xx_write16(stlc, SPI_ADRS_DEV_CTRL_STAT,
891 SPI_CTRL_STAT_HOST_OVERRIDE | SPI_CTRL_STAT_HOST_RESET
892 | SPI_CTRL_STAT_START_HALTED);
893
894 msleep(TARGET_BOOT_SLEEP);
895
896 stlc45xx_write16(stlc, SPI_ADRS_DEV_CTRL_STAT,
897 SPI_CTRL_STAT_HOST_OVERRIDE
898 | SPI_CTRL_STAT_START_HALTED);
899
900 msleep(TARGET_BOOT_SLEEP);
901
902 fw_addr = FIRMWARE_ADDRESS;
903 fw_len = stlc->fw_len;
904
905 while (fw_len > 0) {
906 _fw_len = (fw_len > SPI_MAX_PACKET_SIZE)
907 ? SPI_MAX_PACKET_SIZE : fw_len;
908 dma_regs.cmd = SPI_DMA_WRITE_CTRL_ENABLE;
909 dma_regs.len = cpu_to_le16(_fw_len);
910 dma_regs.addr = cpu_to_le32(fw_addr);
911
912 fw_len -= _fw_len;
913 fw_addr += _fw_len;
914
915 stlc45xx_write16(stlc, SPI_ADRS_DMA_WRITE_CTRL, dma_regs.cmd);
916
917 if (stlc45xx_wait_bit(stlc, SPI_ADRS_DMA_WRITE_CTRL,
918 HOST_ALLOWED, HOST_ALLOWED) == 0) {
919 stlc45xx_error("fw_upload not allowed to DMA write");
920 return -EAGAIN;
921 }
922
923 stlc45xx_write16(stlc, SPI_ADRS_DMA_WRITE_LEN, dma_regs.len);
924 stlc45xx_write32(stlc, SPI_ADRS_DMA_WRITE_BASE, dma_regs.addr);
925
926 stlc45xx_spi_write(stlc, SPI_ADRS_DMA_DATA, stlc->fw, _fw_len);
927
928 /* FIXME: I think this doesn't work if firmware is large,
929 * this loop goes to second round. fw->data is not
930 * increased at all! */
931 }
932
933 BUG_ON(fw_len != 0);
934
935 /* enable host interrupts */
936 stlc45xx_write32(stlc, SPI_ADRS_HOST_INT_EN, SPI_HOST_INTS_DEFAULT);
937
938 /* boot the device */
939 stlc45xx_write16(stlc, SPI_ADRS_DEV_CTRL_STAT,
940 SPI_CTRL_STAT_HOST_OVERRIDE | SPI_CTRL_STAT_HOST_RESET
941 | SPI_CTRL_STAT_RAM_BOOT);
942
943 msleep(TARGET_BOOT_SLEEP);
944
945 stlc45xx_write16(stlc, SPI_ADRS_DEV_CTRL_STAT,
946 SPI_CTRL_STAT_HOST_OVERRIDE | SPI_CTRL_STAT_RAM_BOOT);
947 msleep(TARGET_BOOT_SLEEP);
948
949 return 0;
950 }
951
952 /* caller must hold tx_lock */
953 static void stlc45xx_check_txsent(struct stlc45xx *stlc)
954 {
955 struct txbuffer *entry, *n;
956
957 list_for_each_entry_safe(entry, n, &stlc->tx_sent, tx_list) {
958 if (time_after(jiffies, entry->lifetime)) {
959 if (net_ratelimit())
960 stlc45xx_warning("frame 0x%x lifetime exceeded",
961 entry->start);
962 list_del(&entry->tx_list);
963 skb_pull(entry->skb, entry->header_len);
964 ieee80211_tx_status(stlc->hw, entry->skb);
965 stlc45xx_txbuffer_free(stlc, entry);
966 }
967 }
968 }
969
970 static void stlc45xx_power_off(struct stlc45xx *stlc)
971 {
972 disable_irq(gpio_to_irq(stlc45xx_gpio_irq));
973 gpio_set_value(stlc45xx_gpio_power, 0);
974 }
975
976 static void stlc45xx_power_on(struct stlc45xx *stlc)
977 {
978 gpio_set_value(stlc45xx_gpio_power, 1);
979 enable_irq(gpio_to_irq(stlc45xx_gpio_irq));
980
981 /*
982 * need to wait a while before device can be accessed, the length
983 * is just a guess
984 */
985 msleep(10);
986 }
987
988 /* caller must hold tx_lock */
989 static void stlc45xx_flush_queues(struct stlc45xx *stlc)
990 {
991 struct txbuffer *entry;
992
993 while (!list_empty(&stlc->tx_sent)) {
994 entry = list_first_entry(&stlc->tx_sent,
995 struct txbuffer, tx_list);
996 list_del(&entry->tx_list);
997 dev_kfree_skb(entry->skb);
998 stlc45xx_txbuffer_free(stlc, entry);
999 }
1000
1001 WARN_ON(!list_empty(&stlc->tx_sent));
1002
1003 while (!list_empty(&stlc->tx_pending)) {
1004 entry = list_first_entry(&stlc->tx_pending,
1005 struct txbuffer, tx_list);
1006 list_del(&entry->tx_list);
1007 dev_kfree_skb(entry->skb);
1008 stlc45xx_txbuffer_free(stlc, entry);
1009 }
1010
1011 WARN_ON(!list_empty(&stlc->tx_pending));
1012 WARN_ON(!list_empty(&stlc->txbuffer));
1013 }
1014
1015 static void stlc45xx_work_reset(struct work_struct *work)
1016 {
1017 struct stlc45xx *stlc = container_of(work, struct stlc45xx,
1018 work_reset);
1019
1020 mutex_lock(&stlc->mutex);
1021
1022 if (stlc->fw_state != FW_STATE_RESET)
1023 goto out;
1024
1025 stlc45xx_power_off(stlc);
1026
1027 mutex_unlock(&stlc->mutex);
1028
1029 /* wait that all work_structs have finished, we can't hold
1030 * stlc->mutex to avoid deadlock */
1031 cancel_work_sync(&stlc->work);
1032
1033 /* FIXME: find out good value to wait for chip power down */
1034 msleep(100);
1035
1036 mutex_lock(&stlc->mutex);
1037
1038 /* FIXME: we should gracefully handle if the state has changed
1039 * after re-acquiring mutex */
1040 WARN_ON(stlc->fw_state != FW_STATE_RESET);
1041
1042 spin_lock_bh(&stlc->tx_lock);
1043 stlc45xx_flush_queues(stlc);
1044 spin_unlock_bh(&stlc->tx_lock);
1045
1046 stlc->fw_state = FW_STATE_RESETTING;
1047
1048 stlc45xx_power_on(stlc);
1049 stlc45xx_upload_firmware(stlc);
1050
1051 out:
1052 mutex_unlock(&stlc->mutex);
1053 }
1054
1055 /* caller must hold mutex */
1056 static void stlc45xx_reset(struct stlc45xx *stlc)
1057 {
1058 stlc45xx_warning("resetting firmware");
1059 stlc->fw_state = FW_STATE_RESET;
1060 ieee80211_stop_queues(stlc->hw);
1061 queue_work(stlc->hw->workqueue, &stlc->work_reset);
1062 }
1063
1064 static void stlc45xx_work_tx_timeout(struct work_struct *work)
1065 {
1066 struct stlc45xx *stlc = container_of(work, struct stlc45xx,
1067 work_tx_timeout.work);
1068
1069 stlc45xx_warning("tx timeout");
1070
1071 mutex_lock(&stlc->mutex);
1072
1073 if (stlc->fw_state != FW_STATE_READY)
1074 goto out;
1075
1076 stlc45xx_reset(stlc);
1077
1078 out:
1079 mutex_unlock(&stlc->mutex);
1080 }
1081
1082 static void stlc45xx_int_ack(struct stlc45xx *stlc, u32 val)
1083 {
1084 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
1085
1086 stlc45xx_write32(stlc, SPI_ADRS_HOST_INT_ACK, val);
1087 }
1088
1089 static void stlc45xx_wakeup(struct stlc45xx *stlc)
1090 {
1091 unsigned long timeout;
1092 u32 ints;
1093
1094 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
1095
1096 /* wake the chip */
1097 stlc45xx_write32(stlc, SPI_ADRS_ARM_INTERRUPTS, SPI_TARGET_INT_WAKEUP);
1098
1099 /* And wait for the READY interrupt */
1100 timeout = jiffies + HZ;
1101
1102 ints = stlc45xx_read32(stlc, SPI_ADRS_HOST_INTERRUPTS);
1103 while (!(ints & SPI_HOST_INT_READY)) {
1104 if (time_after(jiffies, timeout))
1105 goto out;
1106 ints = stlc45xx_read32(stlc, SPI_ADRS_HOST_INTERRUPTS);
1107 }
1108
1109 stlc45xx_int_ack(stlc, SPI_HOST_INT_READY);
1110
1111 out:
1112 return;
1113 }
1114
1115 static void stlc45xx_sleep(struct stlc45xx *stlc)
1116 {
1117 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
1118
1119 stlc45xx_write32(stlc, SPI_ADRS_ARM_INTERRUPTS, SPI_TARGET_INT_SLEEP);
1120 }
1121
1122 static void stlc45xx_int_ready(struct stlc45xx *stlc)
1123 {
1124 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
1125
1126 stlc45xx_write32(stlc, SPI_ADRS_HOST_INT_EN,
1127 SPI_HOST_INT_UPDATE | SPI_HOST_INT_SW_UPDATE);
1128
1129 switch (stlc->fw_state) {
1130 case FW_STATE_BOOTING:
1131 stlc->fw_state = FW_STATE_READY;
1132 complete(&stlc->fw_comp);
1133 break;
1134 case FW_STATE_RESETTING:
1135 stlc->fw_state = FW_STATE_READY;
1136
1137 stlc45xx_tx_scan(stlc);
1138 stlc45xx_tx_setup(stlc);
1139 stlc45xx_tx_edcf(stlc);
1140
1141 ieee80211_wake_queues(stlc->hw);
1142 break;
1143 default:
1144 break;
1145 }
1146 }
1147
1148 static int stlc45xx_rx_txack(struct stlc45xx *stlc, struct sk_buff *skb)
1149 {
1150 struct ieee80211_tx_info *info;
1151 struct s_lm_control *control;
1152 struct s_lmo_tx *tx;
1153 struct txbuffer *entry;
1154 int found = 0;
1155
1156 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
1157
1158 control = (struct s_lm_control *) skb->data;
1159 tx = (struct s_lmo_tx *) (control + 1);
1160
1161 if (list_empty(&stlc->tx_sent)) {
1162 if (net_ratelimit())
1163 stlc45xx_warning("no frames waiting for "
1164 "acknowledgement");
1165 return -1;
1166 }
1167
1168 list_for_each_entry(entry, &stlc->tx_sent, tx_list) {
1169 if (control->handle == entry->handle) {
1170 found = 1;
1171 break;
1172 }
1173 }
1174
1175 if (!found) {
1176 if (net_ratelimit())
1177 stlc45xx_warning("couldn't find frame for tx ack 0x%x",
1178 control->handle);
1179 return -1;
1180 }
1181
1182 stlc45xx_debug(DEBUG_TX, "TX ACK 0x%x", entry->handle);
1183
1184 if (entry->status_needed) {
1185 info = IEEE80211_SKB_CB(entry->skb);
1186
1187 if (!(tx->flags & LM_TX_FAILED)) {
1188 /* frame was acked */
1189 info->flags |= IEEE80211_TX_STAT_ACK;
1190 info->status.ack_signal = tx->rcpi / 2 - 110;
1191 }
1192
1193 skb_pull(entry->skb, entry->header_len);
1194
1195 ieee80211_tx_status(stlc->hw, entry->skb);
1196 }
1197
1198 list_del(&entry->tx_list);
1199
1200 stlc45xx_check_txsent(stlc);
1201 if (list_empty(&stlc->tx_sent))
1202 /* there are no pending frames, we can stop the tx timeout
1203 * timer */
1204 cancel_delayed_work(&stlc->work_tx_timeout);
1205
1206 spin_lock_bh(&stlc->tx_lock);
1207
1208 stlc45xx_txbuffer_free(stlc, entry);
1209
1210 if (stlc->tx_queue_stopped &&
1211 stlc45xx_txbuffer_find(stlc, MAX_FRAME_LEN) != -1) {
1212 stlc45xx_debug(DEBUG_QUEUE, "room in tx buffer, waking queues");
1213 ieee80211_wake_queues(stlc->hw);
1214 stlc->tx_queue_stopped = 0;
1215 }
1216
1217 spin_unlock_bh(&stlc->tx_lock);
1218
1219 return 0;
1220 }
1221
1222 static int stlc45xx_rx_control(struct stlc45xx *stlc, struct sk_buff *skb)
1223 {
1224 struct s_lm_control *control;
1225 int ret = 0;
1226
1227 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
1228
1229 control = (struct s_lm_control *) skb->data;
1230
1231 switch (control->oid) {
1232 case LM_OID_TX:
1233 ret = stlc45xx_rx_txack(stlc, skb);
1234 break;
1235 case LM_OID_SETUP:
1236 case LM_OID_SCAN:
1237 case LM_OID_TRAP:
1238 case LM_OID_EDCF:
1239 case LM_OID_KEYCACHE:
1240 case LM_OID_PSM:
1241 case LM_OID_STATS:
1242 case LM_OID_LED:
1243 default:
1244 stlc45xx_warning("unhandled rx control oid %d\n",
1245 control->oid);
1246 break;
1247 }
1248
1249 dev_kfree_skb(skb);
1250
1251 return ret;
1252 }
1253
1254 /* copied from mac80211 */
1255 static void stlc45xx_parse_elems(u8 *start, size_t len,
1256 struct stlc45xx_ie_tim **tim,
1257 size_t *tim_len)
1258 {
1259 size_t left = len;
1260 u8 *pos = start;
1261
1262 while (left >= 2) {
1263 u8 id, elen;
1264
1265 id = *pos++;
1266 elen = *pos++;
1267 left -= 2;
1268
1269 if (elen > left)
1270 return;
1271
1272 switch (id) {
1273 case WLAN_EID_TIM:
1274 *tim = (struct stlc45xx_ie_tim *) pos;
1275 *tim_len = elen;
1276 break;
1277 default:
1278 break;
1279 }
1280
1281 left -= elen;
1282 pos += elen;
1283 }
1284 }
1285
1286 /*
1287 * mac80211 doesn't have support for asking frames with PS-Poll, so let's
1288 * implement in the driver for now. We have to add support to mac80211
1289 * later.
1290 */
1291 static int stlc45xx_check_more_data(struct stlc45xx *stlc, struct sk_buff *skb)
1292 {
1293 struct s_lm_data_in *data = (struct s_lm_data_in *) skb->data;
1294 struct ieee80211_hdr *hdr;
1295 size_t len;
1296 u16 fc;
1297
1298 hdr = (void *) skb->data + sizeof(*data);
1299 len = skb->len - sizeof(*data);
1300
1301 /* minimum frame length is the null frame length 24 bytes */
1302 if (len < 24) {
1303 stlc45xx_warning("invalid frame length when checking for "
1304 "more data");
1305 return -EINVAL;
1306 }
1307
1308 fc = le16_to_cpu(hdr->frame_control);
1309 if (!(fc & IEEE80211_FCTL_FROMDS))
1310 /* this is not from DS */
1311 return 0;
1312
1313 if (compare_ether_addr(hdr->addr1, stlc->mac_addr) != 0)
1314 /* the frame was not for us */
1315 return 0;
1316
1317 if (!(fc & IEEE80211_FCTL_MOREDATA)) {
1318 /* AP has no more frames buffered for us */
1319 stlc45xx_debug(DEBUG_PSM, "all buffered frames retrieved");
1320 stlc->pspolling = false;
1321 return 0;
1322 }
1323
1324 /* MOREDATA bit is set, let's ask for a new frame from the AP */
1325 stlc45xx_tx_pspoll(stlc, stlc->psm);
1326
1327 return 0;
1328 }
1329
1330 /*
1331 * mac80211 cannot read TIM from beacons, so let's add a hack to the
1332 * driver. We have to add support to mac80211 later.
1333 */
1334 static int stlc45xx_rx_data_beacon(struct stlc45xx *stlc, struct sk_buff *skb)
1335 {
1336 struct s_lm_data_in *data = (struct s_lm_data_in *) skb->data;
1337 size_t len = skb->len, tim_len = 0, baselen, pvbmap_len;
1338 struct ieee80211_mgmt *mgmt;
1339 struct stlc45xx_ie_tim *tim = NULL;
1340 int bmap_offset, index, aid_bit;
1341
1342 mgmt = (void *) skb->data + sizeof(*data);
1343
1344 baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt;
1345 if (baselen > len) {
1346 stlc45xx_warning("invalid baselen in beacon");
1347 return -EINVAL;
1348 }
1349
1350 stlc45xx_parse_elems(mgmt->u.beacon.variable, len - baselen, &tim,
1351 &tim_len);
1352
1353 if (!tim) {
1354 stlc45xx_warning("didn't find tim from a beacon");
1355 return -EINVAL;
1356 }
1357
1358 bmap_offset = tim->bmap_control & 0xfe;
1359 index = stlc->aid / 8 - bmap_offset;
1360
1361 pvbmap_len = tim_len - 3;
1362 if (index > pvbmap_len)
1363 return -EINVAL;
1364
1365 aid_bit = !!(tim->pvbmap[index] & (1 << stlc->aid % 8));
1366
1367 stlc45xx_debug(DEBUG_PSM, "fc 0x%x duration %d seq %d dtim %u "
1368 "bmap_control 0x%x aid_bit %d",
1369 mgmt->frame_control, mgmt->duration, mgmt->seq_ctrl >> 4,
1370 tim->dtim_count, tim->bmap_control, aid_bit);
1371
1372 if (!aid_bit)
1373 return 0;
1374
1375 stlc->pspolling = true;
1376 stlc45xx_tx_pspoll(stlc, stlc->psm);
1377
1378 return 0;
1379 }
1380
1381 static int stlc45xx_rx_data(struct stlc45xx *stlc, struct sk_buff *skb)
1382 {
1383 struct ieee80211_rx_status status;
1384 struct s_lm_data_in *data = (struct s_lm_data_in *) skb->data;
1385 int align = 0;
1386 u8 *p, align_len;
1387 u16 len;
1388
1389 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
1390
1391 if (stlc->psm) {
1392 if (data->flags & LM_IN_BEACON)
1393 stlc45xx_rx_data_beacon(stlc, skb);
1394 else if (stlc->pspolling && (data->flags & LM_IN_DATA))
1395 stlc45xx_check_more_data(stlc, skb);
1396 }
1397
1398 memset(&status, 0, sizeof(status));
1399
1400 status.freq = data->frequency;
1401 status.signal = data->rcpi / 2 - 110;
1402
1403 /* let's assume that maximum rcpi value is 140 (= 35 dBm) */
1404 status.qual = data->rcpi * 100 / 140;
1405
1406 status.band = IEEE80211_BAND_2GHZ;
1407
1408 /*
1409 * FIXME: this gives warning from __ieee80211_rx()
1410 *
1411 * status.rate_idx = data->rate;
1412 */
1413
1414 len = data->length;
1415
1416 if (data->flags & LM_FLAG_ALIGN)
1417 align = 1;
1418
1419 skb_pull(skb, sizeof(*data));
1420
1421 if (align) {
1422 p = skb->data;
1423 align_len = *p;
1424 skb_pull(skb, align_len);
1425 }
1426
1427 skb_trim(skb, len);
1428
1429 stlc45xx_debug(DEBUG_RX, "rx data 0x%p %d B", skb->data, skb->len);
1430 stlc45xx_dump(DEBUG_RX_CONTENT, skb->data, skb->len);
1431
1432 ieee80211_rx(stlc->hw, skb, &status);
1433
1434 return 0;
1435 }
1436
1437
1438
1439 static int stlc45xx_rx(struct stlc45xx *stlc)
1440 {
1441 struct s_lm_control *control;
1442 struct sk_buff *skb;
1443 int ret;
1444 u16 len;
1445
1446 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
1447
1448 stlc45xx_wakeup(stlc);
1449
1450 /* dummy read to flush SPI DMA controller bug */
1451 stlc45xx_read16(stlc, SPI_ADRS_GEN_PURP_1);
1452
1453 len = stlc45xx_read16(stlc, SPI_ADRS_DMA_DATA);
1454
1455 if (len == 0) {
1456 stlc45xx_warning("rx request of zero bytes");
1457 return 0;
1458 }
1459
1460 skb = dev_alloc_skb(len);
1461 if (!skb) {
1462 stlc45xx_warning("could not alloc skb");
1463 return 0;
1464 }
1465
1466 stlc45xx_spi_read(stlc, SPI_ADRS_DMA_DATA, skb_put(skb, len), len);
1467
1468 stlc45xx_sleep(stlc);
1469
1470 stlc45xx_debug(DEBUG_RX, "rx frame 0x%p %d B", skb->data, skb->len);
1471 stlc45xx_dump(DEBUG_RX_CONTENT, skb->data, skb->len);
1472
1473 control = (struct s_lm_control *) skb->data;
1474
1475 if (control->flags & LM_FLAG_CONTROL)
1476 ret = stlc45xx_rx_control(stlc, skb);
1477 else
1478 ret = stlc45xx_rx_data(stlc, skb);
1479
1480 return ret;
1481 }
1482
1483
1484 static irqreturn_t stlc45xx_interrupt(int irq, void *config)
1485 {
1486 struct spi_device *spi = config;
1487 struct stlc45xx *stlc = dev_get_drvdata(&spi->dev);
1488
1489 stlc45xx_debug(DEBUG_IRQ, "IRQ");
1490
1491 queue_work(stlc->hw->workqueue, &stlc->work);
1492
1493 return IRQ_HANDLED;
1494 }
1495
1496 static int stlc45xx_tx_frame(struct stlc45xx *stlc, u32 address,
1497 void *buf, size_t len)
1498 {
1499 struct s_dma_regs dma_regs;
1500 unsigned long timeout;
1501 int ret = 0;
1502 u32 ints;
1503
1504 stlc->tx_frames++;
1505
1506 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
1507
1508 stlc45xx_debug(DEBUG_TX, "tx frame 0x%p %zu B", buf, len);
1509 stlc45xx_dump(DEBUG_TX_CONTENT, buf, len);
1510
1511 stlc45xx_wakeup(stlc);
1512
1513 dma_regs.cmd = SPI_DMA_WRITE_CTRL_ENABLE;
1514 dma_regs.len = cpu_to_le16(len);
1515 dma_regs.addr = cpu_to_le32(address);
1516
1517 stlc45xx_spi_write(stlc, SPI_ADRS_DMA_WRITE_CTRL, &dma_regs,
1518 sizeof(dma_regs));
1519
1520 stlc45xx_spi_write(stlc, SPI_ADRS_DMA_DATA, buf, len);
1521
1522 timeout = jiffies + 2 * HZ;
1523 ints = stlc45xx_read32(stlc, SPI_ADRS_HOST_INTERRUPTS);
1524 while (!(ints & SPI_HOST_INT_WR_READY)) {
1525 if (time_after(jiffies, timeout)) {
1526 stlc45xx_warning("WR_READY timeout");
1527 ret = -1;
1528 goto out;
1529 }
1530 ints = stlc45xx_read32(stlc, SPI_ADRS_HOST_INTERRUPTS);
1531 }
1532
1533 stlc45xx_int_ack(stlc, SPI_HOST_INT_WR_READY);
1534
1535 stlc45xx_sleep(stlc);
1536
1537 out:
1538 return ret;
1539 }
1540
1541 static int stlc45xx_wq_tx(struct stlc45xx *stlc)
1542 {
1543 struct txbuffer *entry;
1544 int ret = 0;
1545
1546 spin_lock_bh(&stlc->tx_lock);
1547
1548 while (!list_empty(&stlc->tx_pending)) {
1549 entry = list_entry(stlc->tx_pending.next,
1550 struct txbuffer, tx_list);
1551
1552 list_del_init(&entry->tx_list);
1553
1554 spin_unlock_bh(&stlc->tx_lock);
1555
1556 ret = stlc45xx_tx_frame(stlc, entry->frame_start,
1557 entry->skb->data, entry->skb->len);
1558
1559 spin_lock_bh(&stlc->tx_lock);
1560
1561 if (ret < 0) {
1562 /* frame transfer to firmware buffer failed */
1563 /* FIXME: report this to mac80211 */
1564 dev_kfree_skb(entry->skb);
1565 stlc45xx_txbuffer_free(stlc, entry);
1566 goto out;
1567 }
1568
1569 list_add(&entry->tx_list, &stlc->tx_sent);
1570 queue_delayed_work(stlc->hw->workqueue,
1571 &stlc->work_tx_timeout,
1572 msecs_to_jiffies(TX_TIMEOUT));
1573 }
1574
1575 out:
1576 spin_unlock_bh(&stlc->tx_lock);
1577 return ret;
1578 }
1579
1580 static void stlc45xx_work(struct work_struct *work)
1581 {
1582 struct stlc45xx *stlc = container_of(work, struct stlc45xx, work);
1583 u32 ints;
1584 int ret;
1585
1586 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
1587
1588 mutex_lock(&stlc->mutex);
1589
1590 if (stlc->fw_state == FW_STATE_OFF &&
1591 stlc->fw_state == FW_STATE_RESET)
1592 goto out;
1593
1594 ints = stlc45xx_read32(stlc, SPI_ADRS_HOST_INTERRUPTS);
1595 stlc45xx_debug(DEBUG_BH, "begin host_ints 0x%08x", ints);
1596
1597 if (ints & SPI_HOST_INT_READY) {
1598 stlc45xx_int_ready(stlc);
1599 stlc45xx_int_ack(stlc, SPI_HOST_INT_READY);
1600 }
1601
1602 if (stlc->fw_state != FW_STATE_READY)
1603 goto out;
1604
1605 if (ints & SPI_HOST_INT_UPDATE) {
1606 stlc45xx_int_ack(stlc, SPI_HOST_INT_UPDATE);
1607 ret = stlc45xx_rx(stlc);
1608 if (ret < 0) {
1609 stlc45xx_reset(stlc);
1610 goto out;
1611 }
1612 }
1613 if (ints & SPI_HOST_INT_SW_UPDATE) {
1614 stlc45xx_int_ack(stlc, SPI_HOST_INT_SW_UPDATE);
1615 ret = stlc45xx_rx(stlc);
1616 if (ret < 0) {
1617 stlc45xx_reset(stlc);
1618 goto out;
1619 }
1620 }
1621
1622 ret = stlc45xx_wq_tx(stlc);
1623 if (ret < 0) {
1624 stlc45xx_reset(stlc);
1625 goto out;
1626 }
1627
1628 ints = stlc45xx_read32(stlc, SPI_ADRS_HOST_INTERRUPTS);
1629 stlc45xx_debug(DEBUG_BH, "end host_ints 0x%08x", ints);
1630
1631 out:
1632 mutex_unlock(&stlc->mutex);
1633 }
1634
1635 static void stlc45xx_tx_edcf(struct stlc45xx *stlc)
1636 {
1637 struct s_lm_control *control;
1638 struct s_lmo_edcf *edcf;
1639 size_t len, edcf_len;
1640
1641 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
1642
1643 edcf_len = sizeof(*edcf);
1644 len = sizeof(*control) + edcf_len;
1645 control = kzalloc(len, GFP_KERNEL);
1646 edcf = (struct s_lmo_edcf *) (control + 1);
1647
1648 control->flags = LM_FLAG_CONTROL | LM_CTRL_OPSET;
1649 control->length = edcf_len;
1650 control->oid = LM_OID_EDCF;
1651
1652 edcf->slottime = 0x14;
1653 edcf->sifs = 10;
1654 edcf->eofpad = 6;
1655 edcf->maxburst = 1500;
1656
1657 edcf->queues[0].aifs = 2;
1658 edcf->queues[0].pad0 = 1;
1659 edcf->queues[0].cwmin = 3;
1660 edcf->queues[0].cwmax = 7;
1661 edcf->queues[0].txop = 47;
1662 edcf->queues[1].aifs = 2;
1663 edcf->queues[1].pad0 = 0;
1664 edcf->queues[1].cwmin = 7;
1665 edcf->queues[1].cwmax = 15;
1666 edcf->queues[1].txop = 94;
1667 edcf->queues[2].aifs = 3;
1668 edcf->queues[2].pad0 = 0;
1669 edcf->queues[2].cwmin = 15;
1670 edcf->queues[2].cwmax = 1023;
1671 edcf->queues[2].txop = 0;
1672 edcf->queues[3].aifs = 7;
1673 edcf->queues[3].pad0 = 0;
1674 edcf->queues[3].cwmin = 15;
1675 edcf->queues[3].cwmax = 1023;
1676 edcf->queues[3].txop = 0;
1677 edcf->queues[4].aifs = 13;
1678 edcf->queues[4].pad0 = 99;
1679 edcf->queues[4].cwmin = 3437;
1680 edcf->queues[4].cwmax = 512;
1681 edcf->queues[4].txop = 12;
1682 edcf->queues[5].aifs = 142;
1683 edcf->queues[5].pad0 = 109;
1684 edcf->queues[5].cwmin = 8756;
1685 edcf->queues[5].cwmax = 6;
1686 edcf->queues[5].txop = 0;
1687 edcf->queues[6].aifs = 4;
1688 edcf->queues[6].pad0 = 0;
1689 edcf->queues[6].cwmin = 0;
1690 edcf->queues[6].cwmax = 58705;
1691 edcf->queues[6].txop = 25716;
1692 edcf->queues[7].aifs = 0;
1693 edcf->queues[7].pad0 = 0;
1694 edcf->queues[7].cwmin = 0;
1695 edcf->queues[7].cwmax = 0;
1696 edcf->queues[7].txop = 0;
1697
1698 stlc45xx_tx_frame(stlc, FIRMWARE_CONFIG_START, control, len);
1699
1700 kfree(control);
1701 }
1702
1703 static void stlc45xx_tx_setup(struct stlc45xx *stlc)
1704 {
1705 struct s_lm_control *control;
1706 struct s_lmo_setup *setup;
1707 size_t len, setup_len;
1708
1709 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
1710
1711 setup_len = sizeof(*setup);
1712 len = sizeof(*control) + setup_len;
1713 control = kzalloc(len, GFP_KERNEL);
1714 setup = (struct s_lmo_setup *) (control + 1);
1715
1716 control->flags = LM_FLAG_CONTROL | LM_CTRL_OPSET;
1717 control->length = setup_len;
1718 control->oid = LM_OID_SETUP;
1719
1720 setup->flags = LM_SETUP_INFRA;
1721 setup->antenna = 2;
1722 setup->rx_align = 0;
1723 setup->rx_buffer = FIRMWARE_RXBUFFER_START;
1724 setup->rx_mtu = FIRMWARE_MTU;
1725 setup->frontend = 5;
1726 setup->timeout = 0;
1727 setup->truncate = 48896;
1728 setup->bratemask = 0xffffffff;
1729 setup->ref_clock = 644245094;
1730 setup->lpf_bandwidth = 65535;
1731 setup->osc_start_delay = 65535;
1732
1733 memcpy(setup->macaddr, stlc->mac_addr, ETH_ALEN);
1734 memcpy(setup->bssid, stlc->bssid, ETH_ALEN);
1735
1736 stlc45xx_tx_frame(stlc, FIRMWARE_CONFIG_START, control, len);
1737
1738 kfree(control);
1739 }
1740
1741 static void stlc45xx_tx_scan(struct stlc45xx *stlc)
1742 {
1743 struct s_lm_control *control;
1744 struct s_lmo_scan *scan;
1745 size_t len, scan_len;
1746
1747 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
1748
1749 scan_len = sizeof(*scan);
1750 len = sizeof(*control) + scan_len;
1751 control = kzalloc(len, GFP_KERNEL);
1752 scan = (struct s_lmo_scan *) (control + 1);
1753
1754 control->flags = LM_FLAG_CONTROL | LM_CTRL_OPSET;
1755 control->length = scan_len;
1756 control->oid = LM_OID_SCAN;
1757
1758 scan->flags = LM_SCAN_EXIT;
1759 scan->bratemask = 0x15f;
1760 scan->aloft[0] = 3;
1761 scan->aloft[1] = 3;
1762 scan->aloft[2] = 1;
1763 scan->aloft[3] = 0;
1764 scan->aloft[4] = 0;
1765 scan->aloft[5] = 0;
1766 scan->aloft[6] = 0;
1767 scan->aloft[7] = 0;
1768
1769 memcpy(&scan->rssical, &stlc->cal_rssi[(stlc->channel - 1) *
1770 RSSI_CAL_LEN],
1771 RSSI_CAL_LEN);
1772 memcpy(&scan->channel, &stlc->cal_channels[(stlc->channel - 1) *
1773 CHANNEL_CAL_LEN],
1774 CHANNEL_CAL_LEN);
1775
1776 stlc45xx_tx_frame(stlc, FIRMWARE_CONFIG_START, control, len);
1777
1778 kfree(control);
1779 }
1780
1781 /*
1782 * caller must hold mutex
1783 */
1784 static int stlc45xx_tx_pspoll(struct stlc45xx *stlc, bool powersave)
1785 {
1786 struct ieee80211_hdr *pspoll;
1787 int payload_len, padding, i;
1788 struct s_lm_data_out *data;
1789 struct txbuffer *entry;
1790 struct sk_buff *skb;
1791 char *payload;
1792 u16 fc;
1793
1794 skb = dev_alloc_skb(stlc->hw->extra_tx_headroom + 16);
1795 if (!skb) {
1796 stlc45xx_warning("failed to allocate pspoll frame");
1797 return -ENOMEM;
1798 }
1799 skb_reserve(skb, stlc->hw->extra_tx_headroom);
1800
1801 pspoll = (struct ieee80211_hdr *) skb_put(skb, 16);
1802 memset(pspoll, 0, 16);
1803 fc = IEEE80211_FTYPE_CTL | IEEE80211_STYPE_PSPOLL;
1804 if (powersave)
1805 fc |= IEEE80211_FCTL_PM;
1806 pspoll->frame_control = cpu_to_le16(fc);
1807 pspoll->duration_id = cpu_to_le16(stlc->aid);
1808
1809 /* aid in PS-Poll has its two MSBs each set to 1 */
1810 pspoll->duration_id |= cpu_to_le16(1 << 15) | cpu_to_le16(1 << 14);
1811
1812 memcpy(pspoll->addr1, stlc->bssid, ETH_ALEN);
1813 memcpy(pspoll->addr2, stlc->mac_addr, ETH_ALEN);
1814
1815 stlc45xx_debug(DEBUG_PSM, "sending PS-Poll frame to %pM (powersave %d, "
1816 "fc 0x%x, aid %d)", pspoll->addr1,
1817 powersave, fc, stlc->aid);
1818
1819 spin_lock_bh(&stlc->tx_lock);
1820
1821 entry = stlc45xx_txbuffer_alloc(stlc, skb->len);
1822
1823 spin_unlock_bh(&stlc->tx_lock);
1824
1825 if (!entry) {
1826 /*
1827 * The queue should be stopped before the firmware buffer
1828 * is full, so firmware buffer should always have enough
1829 * space.
1830 *
1831 * But I'm too lazy and omit it for now.
1832 */
1833 if (net_ratelimit())
1834 stlc45xx_warning("firmware tx buffer full is full "
1835 "for null frame");
1836 return -ENOSPC;
1837 }
1838
1839 payload = skb->data;
1840 payload_len = skb->len;
1841 padding = (int) (skb->data - sizeof(*data)) & 3;
1842 entry->header_len = sizeof(*data) + padding;
1843
1844 entry->skb = skb;
1845 entry->status_needed = false;
1846 entry->handle = (u32) skb;
1847 entry->lifetime = jiffies + msecs_to_jiffies(TX_FRAME_LIFETIME);
1848
1849 stlc45xx_debug(DEBUG_TX, "tx data 0x%x (0x%p payload %d B "
1850 "padding %d header_len %d)",
1851 entry->handle, payload, payload_len, padding,
1852 entry->header_len);
1853 stlc45xx_dump(DEBUG_TX_CONTENT, payload, payload_len);
1854
1855 data = (struct s_lm_data_out *) skb_push(skb, entry->header_len);
1856
1857 memset(data, 0, entry->header_len);
1858
1859 if (padding)
1860 data->flags = LM_FLAG_ALIGN;
1861
1862 data->flags = LM_OUT_BURST;
1863 data->length = payload_len;
1864 data->handle = entry->handle;
1865 data->aid = 1;
1866 data->rts_retries = 7;
1867 data->retries = 7;
1868 data->aloft_ctrl = 0;
1869 data->crypt_offset = 58;
1870 data->keytype = 0;
1871 data->keylen = 0;
1872 data->queue = LM_QUEUE_DATA3;
1873 data->backlog = 32;
1874 data->antenna = 2;
1875 data->cts = 3;
1876 data->power = 127;
1877
1878 for (i = 0; i < 8; i++)
1879 data->aloft[i] = 0;
1880
1881 /*
1882 * check if there's enough space in tx buffer
1883 *
1884 * FIXME: ignored for now
1885 */
1886
1887 stlc45xx_tx_frame(stlc, entry->start, skb->data, skb->len);
1888
1889 list_add(&entry->tx_list, &stlc->tx_sent);
1890
1891 return 0;
1892 }
1893
1894 /*
1895 * caller must hold mutex
1896 *
1897 * shamelessly stolen from mac80211/ieee80211_send_nullfunc
1898 */
1899 static int stlc45xx_tx_nullfunc(struct stlc45xx *stlc, bool powersave)
1900 {
1901 struct ieee80211_hdr *nullfunc;
1902 int payload_len, padding, i;
1903 struct s_lm_data_out *data;
1904 struct txbuffer *entry;
1905 struct sk_buff *skb;
1906 char *payload;
1907 u16 fc;
1908
1909 skb = dev_alloc_skb(stlc->hw->extra_tx_headroom + 24);
1910 if (!skb) {
1911 stlc45xx_warning("failed to allocate buffer for null frame\n");
1912 return -ENOMEM;
1913 }
1914 skb_reserve(skb, stlc->hw->extra_tx_headroom);
1915
1916 nullfunc = (struct ieee80211_hdr *) skb_put(skb, 24);
1917 memset(nullfunc, 0, 24);
1918 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |
1919 IEEE80211_FCTL_TODS;
1920
1921 if (powersave)
1922 fc |= IEEE80211_FCTL_PM;
1923
1924 nullfunc->frame_control = cpu_to_le16(fc);
1925 memcpy(nullfunc->addr1, stlc->bssid, ETH_ALEN);
1926 memcpy(nullfunc->addr2, stlc->mac_addr, ETH_ALEN);
1927 memcpy(nullfunc->addr3, stlc->bssid, ETH_ALEN);
1928
1929 stlc45xx_debug(DEBUG_PSM, "sending Null frame to %pM (powersave %d, "
1930 "fc 0x%x)", nullfunc->addr1, powersave, fc);
1931
1932 spin_lock_bh(&stlc->tx_lock);
1933
1934 entry = stlc45xx_txbuffer_alloc(stlc, skb->len);
1935
1936 spin_unlock_bh(&stlc->tx_lock);
1937
1938 if (!entry) {
1939 /*
1940 * The queue should be stopped before the firmware buffer
1941 * is full, so firmware buffer should always have enough
1942 * space.
1943 *
1944 * But I'm too lazy and omit it for now.
1945 */
1946 if (net_ratelimit())
1947 stlc45xx_warning("firmware tx buffer full is full "
1948 "for null frame");
1949 return -ENOSPC;
1950 }
1951
1952 payload = skb->data;
1953 payload_len = skb->len;
1954 padding = (int) (skb->data - sizeof(*data)) & 3;
1955 entry->header_len = sizeof(*data) + padding;
1956
1957 entry->skb = skb;
1958 entry->status_needed = false;
1959 entry->handle = (u32) skb;
1960 entry->lifetime = jiffies + msecs_to_jiffies(TX_FRAME_LIFETIME);
1961
1962 stlc45xx_debug(DEBUG_TX, "tx data 0x%x (0x%p payload %d B "
1963 "padding %d header_len %d)",
1964 entry->handle, payload, payload_len, padding,
1965 entry->header_len);
1966 stlc45xx_dump(DEBUG_TX_CONTENT, payload, payload_len);
1967
1968 data = (struct s_lm_data_out *) skb_push(skb, entry->header_len);
1969
1970 memset(data, 0, entry->header_len);
1971
1972 if (padding)
1973 data->flags = LM_FLAG_ALIGN;
1974
1975 data->flags = LM_OUT_BURST;
1976 data->length = payload_len;
1977 data->handle = entry->handle;
1978 data->aid = 1;
1979 data->rts_retries = 7;
1980 data->retries = 7;
1981 data->aloft_ctrl = 0;
1982 data->crypt_offset = 58;
1983 data->keytype = 0;
1984 data->keylen = 0;
1985 data->queue = LM_QUEUE_DATA3;
1986 data->backlog = 32;
1987 data->antenna = 2;
1988 data->cts = 3;
1989 data->power = 127;
1990
1991 for (i = 0; i < 8; i++)
1992 data->aloft[i] = 0;
1993
1994 /*
1995 * check if there's enough space in tx buffer
1996 *
1997 * FIXME: ignored for now
1998 */
1999
2000 stlc45xx_tx_frame(stlc, entry->start, skb->data, skb->len);
2001
2002 list_add(&entry->tx_list, &stlc->tx_sent);
2003
2004 return 0;
2005 }
2006
2007 /* caller must hold mutex */
2008 static void stlc45xx_tx_psm(struct stlc45xx *stlc, bool enable)
2009 {
2010 struct s_lm_control *control;
2011 struct s_lmo_psm *psm;
2012 size_t len, psm_len;
2013
2014 WARN_ON(!stlc->associated);
2015 WARN_ON(stlc->aid < 1);
2016 WARN_ON(stlc->aid > 2007);
2017
2018 psm_len = sizeof(*psm);
2019 len = sizeof(*control) + psm_len;
2020 control = kzalloc(len, GFP_KERNEL);
2021 psm = (struct s_lmo_psm *) (control + 1);
2022
2023 control->flags = LM_FLAG_CONTROL | LM_CTRL_OPSET;
2024 control->length = psm_len;
2025 control->oid = LM_OID_PSM;
2026
2027 if (enable)
2028 psm->flags |= LM_PSM;
2029
2030 psm->aid = stlc->aid;
2031
2032 psm->beacon_rcpi_skip_max = 60;
2033
2034 psm->intervals[0].interval = 1;
2035 psm->intervals[0].periods = 1;
2036 psm->intervals[1].interval = 1;
2037 psm->intervals[1].periods = 1;
2038 psm->intervals[2].interval = 1;
2039 psm->intervals[2].periods = 1;
2040 psm->intervals[3].interval = 1;
2041 psm->intervals[3].periods = 1;
2042
2043 psm->nr = 0;
2044 psm->exclude[0] = 0;
2045
2046 stlc45xx_debug(DEBUG_PSM, "sending LM_OID_PSM (aid %d, interval %d)",
2047 psm->aid, psm->intervals[0].interval);
2048
2049 stlc45xx_tx_frame(stlc, FIRMWARE_CONFIG_START, control, len);
2050
2051 kfree(control);
2052 }
2053
2054 static int stlc45xx_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
2055 {
2056 struct stlc45xx *stlc = hw->priv;
2057 struct ieee80211_tx_info *info;
2058 struct ieee80211_rate *rate;
2059 int payload_len, padding, i;
2060 struct s_lm_data_out *data;
2061 struct txbuffer *entry;
2062 char *payload;
2063
2064 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2065
2066 spin_lock_bh(&stlc->tx_lock);
2067
2068 entry = stlc45xx_txbuffer_alloc(stlc, skb->len);
2069 if (!entry) {
2070 /* the queue should be stopped before the firmware buffer
2071 * is full, so firmware buffer should always have enough
2072 * space */
2073 if (net_ratelimit())
2074 stlc45xx_warning("firmware buffer full");
2075 spin_unlock_bh(&stlc->tx_lock);
2076 return NETDEV_TX_BUSY;
2077 }
2078
2079 info = IEEE80211_SKB_CB(skb);
2080
2081 payload = skb->data;
2082 payload_len = skb->len;
2083 padding = (int) (skb->data - sizeof(*data)) & 3;
2084 entry->header_len = sizeof(*data) + padding;
2085
2086 entry->skb = skb;
2087 entry->status_needed = true;
2088 entry->handle = (u32) skb;
2089 entry->lifetime = jiffies + msecs_to_jiffies(TX_FRAME_LIFETIME);
2090
2091 stlc45xx_debug(DEBUG_TX, "tx data 0x%x (0x%p payload %d B "
2092 "padding %d header_len %d)",
2093 entry->handle, payload, payload_len, padding,
2094 entry->header_len);
2095 stlc45xx_dump(DEBUG_TX_CONTENT, payload, payload_len);
2096
2097 data = (struct s_lm_data_out *) skb_push(skb, entry->header_len);
2098
2099 memset(data, 0, entry->header_len);
2100
2101 if (padding)
2102 data->flags = LM_FLAG_ALIGN;
2103
2104 data->flags = LM_OUT_BURST;
2105 data->length = payload_len;
2106 data->handle = entry->handle;
2107 data->aid = 1;
2108 data->rts_retries = 7;
2109 data->retries = 7;
2110 data->aloft_ctrl = 0;
2111 data->crypt_offset = 58;
2112 data->keytype = 0;
2113 data->keylen = 0;
2114 data->queue = 2;
2115 data->backlog = 32;
2116 data->antenna = 2;
2117 data->cts = 3;
2118 data->power = 127;
2119
2120 for (i = 0; i < 8; i++) {
2121 rate = ieee80211_get_tx_rate(stlc->hw, info);
2122 data->aloft[i] = rate->hw_value;
2123 }
2124
2125 list_add_tail(&entry->tx_list, &stlc->tx_pending);
2126
2127 /* check if there's enough space in tx buffer */
2128 if (stlc45xx_txbuffer_find(stlc, MAX_FRAME_LEN) == -1) {
2129 stlc45xx_debug(DEBUG_QUEUE, "tx buffer full, stopping queues");
2130 stlc->tx_queue_stopped = 1;
2131 ieee80211_stop_queues(stlc->hw);
2132 }
2133
2134 queue_work(stlc->hw->workqueue, &stlc->work);
2135
2136 spin_unlock_bh(&stlc->tx_lock);
2137
2138 return NETDEV_TX_OK;
2139 }
2140
2141 static int stlc45xx_op_start(struct ieee80211_hw *hw)
2142 {
2143 struct stlc45xx *stlc = hw->priv;
2144 unsigned long timeout;
2145 int ret = 0;
2146
2147 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2148
2149 mutex_lock(&stlc->mutex);
2150
2151 stlc->fw_state = FW_STATE_BOOTING;
2152 stlc->channel = 1;
2153
2154 stlc45xx_power_on(stlc);
2155
2156 ret = stlc45xx_upload_firmware(stlc);
2157 if (ret < 0) {
2158 stlc45xx_power_off(stlc);
2159 goto out_unlock;
2160 }
2161
2162 stlc->tx_queue_stopped = 0;
2163
2164 mutex_unlock(&stlc->mutex);
2165
2166 timeout = msecs_to_jiffies(2000);
2167 timeout = wait_for_completion_interruptible_timeout(&stlc->fw_comp,
2168 timeout);
2169 if (!timeout) {
2170 stlc45xx_error("firmware boot failed");
2171 stlc45xx_power_off(stlc);
2172 ret = -1;
2173 goto out;
2174 }
2175
2176 stlc45xx_debug(DEBUG_BOOT, "firmware booted");
2177
2178 /* FIXME: should we take mutex just after wait_for_completion()? */
2179 mutex_lock(&stlc->mutex);
2180
2181 WARN_ON(stlc->fw_state != FW_STATE_READY);
2182
2183 out_unlock:
2184 mutex_unlock(&stlc->mutex);
2185
2186 out:
2187 return ret;
2188 }
2189
2190 static void stlc45xx_op_stop(struct ieee80211_hw *hw)
2191 {
2192 struct stlc45xx *stlc = hw->priv;
2193
2194 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2195
2196 mutex_lock(&stlc->mutex);
2197
2198 WARN_ON(stlc->fw_state != FW_STATE_READY);
2199
2200 stlc45xx_power_off(stlc);
2201
2202 /* FIXME: make sure that all work_structs have completed */
2203
2204 spin_lock_bh(&stlc->tx_lock);
2205 stlc45xx_flush_queues(stlc);
2206 spin_unlock_bh(&stlc->tx_lock);
2207
2208 stlc->fw_state = FW_STATE_OFF;
2209
2210 mutex_unlock(&stlc->mutex);
2211 }
2212
2213 static int stlc45xx_op_add_interface(struct ieee80211_hw *hw,
2214 struct ieee80211_if_init_conf *conf)
2215 {
2216 struct stlc45xx *stlc = hw->priv;
2217
2218 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2219
2220 switch (conf->type) {
2221 case NL80211_IFTYPE_STATION:
2222 break;
2223 default:
2224 return -EOPNOTSUPP;
2225 }
2226
2227 memcpy(stlc->mac_addr, conf->mac_addr, ETH_ALEN);
2228
2229 return 0;
2230 }
2231
2232 static void stlc45xx_op_remove_interface(struct ieee80211_hw *hw,
2233 struct ieee80211_if_init_conf *conf)
2234 {
2235 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2236 }
2237
2238 static int stlc45xx_op_config_interface(struct ieee80211_hw *hw,
2239 struct ieee80211_vif *vif,
2240 struct ieee80211_if_conf *conf)
2241 {
2242 struct stlc45xx *stlc = hw->priv;
2243
2244 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2245
2246 mutex_lock(&stlc->mutex);
2247
2248 memcpy(stlc->bssid, conf->bssid, ETH_ALEN);
2249 stlc45xx_tx_setup(stlc);
2250
2251 mutex_unlock(&stlc->mutex);
2252
2253 return 0;
2254 }
2255
2256 static int stlc45xx_op_config(struct ieee80211_hw *hw, u32 changed)
2257 {
2258 struct stlc45xx *stlc = hw->priv;
2259
2260 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2261
2262 mutex_lock(&stlc->mutex);
2263
2264 stlc->channel = hw->conf.channel->hw_value;
2265 stlc45xx_tx_scan(stlc);
2266 stlc45xx_tx_setup(stlc);
2267 stlc45xx_tx_edcf(stlc);
2268
2269 if ((hw->conf.flags & IEEE80211_CONF_PS) != stlc->psm) {
2270 stlc->psm = hw->conf.flags & IEEE80211_CONF_PS;
2271 if (stlc->associated) {
2272 stlc45xx_tx_psm(stlc, stlc->psm);
2273 stlc45xx_tx_nullfunc(stlc, stlc->psm);
2274 }
2275 }
2276
2277 mutex_unlock(&stlc->mutex);
2278
2279 return 0;
2280 }
2281
2282 static void stlc45xx_op_configure_filter(struct ieee80211_hw *hw,
2283 unsigned int changed_flags,
2284 unsigned int *total_flags,
2285 int mc_count,
2286 struct dev_addr_list *mc_list)
2287 {
2288 *total_flags = 0;
2289 }
2290
2291 static void stlc45xx_op_bss_info_changed(struct ieee80211_hw *hw,
2292 struct ieee80211_vif *vif,
2293 struct ieee80211_bss_conf *info,
2294 u32 changed)
2295 {
2296 struct stlc45xx *stlc = hw->priv;
2297
2298 if (changed & BSS_CHANGED_ASSOC) {
2299 stlc->associated = info->assoc;
2300 if (info->assoc)
2301 stlc->aid = info->aid;
2302 else
2303 stlc->aid = -1;
2304
2305 if (stlc->psm) {
2306 stlc45xx_tx_psm(stlc, stlc->psm);
2307 stlc45xx_tx_nullfunc(stlc, stlc->psm);
2308 }
2309 }
2310 }
2311
2312
2313 /* can't be const, mac80211 writes to this */
2314 static struct ieee80211_rate stlc45xx_rates[] = {
2315 { .bitrate = 10, .hw_value = 0, .hw_value_short = 0, },
2316 { .bitrate = 20, .hw_value = 1, .hw_value_short = 1, },
2317 { .bitrate = 55, .hw_value = 2, .hw_value_short = 2, },
2318 { .bitrate = 110, .hw_value = 3, .hw_value_short = 3, },
2319 { .bitrate = 60, .hw_value = 4, .hw_value_short = 4, },
2320 { .bitrate = 90, .hw_value = 5, .hw_value_short = 5, },
2321 { .bitrate = 120, .hw_value = 6, .hw_value_short = 6, },
2322 { .bitrate = 180, .hw_value = 7, .hw_value_short = 7, },
2323 { .bitrate = 240, .hw_value = 8, .hw_value_short = 8, },
2324 { .bitrate = 360, .hw_value = 9, .hw_value_short = 9, },
2325 { .bitrate = 480, .hw_value = 10, .hw_value_short = 10, },
2326 { .bitrate = 540, .hw_value = 11, .hw_value_short = 11, },
2327 };
2328
2329 /* can't be const, mac80211 writes to this */
2330 static struct ieee80211_channel stlc45xx_channels[] = {
2331 { .hw_value = 1, .center_freq = 2412},
2332 { .hw_value = 2, .center_freq = 2417},
2333 { .hw_value = 3, .center_freq = 2422},
2334 { .hw_value = 4, .center_freq = 2427},
2335 { .hw_value = 5, .center_freq = 2432},
2336 { .hw_value = 6, .center_freq = 2437},
2337 { .hw_value = 7, .center_freq = 2442},
2338 { .hw_value = 8, .center_freq = 2447},
2339 { .hw_value = 9, .center_freq = 2452},
2340 { .hw_value = 10, .center_freq = 2457},
2341 { .hw_value = 11, .center_freq = 2462},
2342 { .hw_value = 12, .center_freq = 2467},
2343 { .hw_value = 13, .center_freq = 2472},
2344 };
2345
2346 /* can't be const, mac80211 writes to this */
2347 static struct ieee80211_supported_band stlc45xx_band_2ghz = {
2348 .channels = stlc45xx_channels,
2349 .n_channels = ARRAY_SIZE(stlc45xx_channels),
2350 .bitrates = stlc45xx_rates,
2351 .n_bitrates = ARRAY_SIZE(stlc45xx_rates),
2352 };
2353
2354 static const struct ieee80211_ops stlc45xx_ops = {
2355 .start = stlc45xx_op_start,
2356 .stop = stlc45xx_op_stop,
2357 .add_interface = stlc45xx_op_add_interface,
2358 .remove_interface = stlc45xx_op_remove_interface,
2359 .config = stlc45xx_op_config,
2360 .config_interface = stlc45xx_op_config_interface,
2361 .configure_filter = stlc45xx_op_configure_filter,
2362 .tx = stlc45xx_op_tx,
2363 .bss_info_changed = stlc45xx_op_bss_info_changed,
2364 };
2365
2366 static int stlc45xx_register_mac80211(struct stlc45xx *stlc)
2367 {
2368 /* FIXME: SET_IEEE80211_PERM_ADDR() requires default_mac_addr
2369 to be non-const for some strange reason */
2370 static u8 default_mac_addr[ETH_ALEN] = {
2371 0x00, 0x02, 0xee, 0xc0, 0xff, 0xee
2372 };
2373 int ret;
2374
2375 SET_IEEE80211_PERM_ADDR(stlc->hw, default_mac_addr);
2376
2377 ret = ieee80211_register_hw(stlc->hw);
2378 if (ret) {
2379 stlc45xx_error("unable to register mac80211 hw: %d", ret);
2380 return ret;
2381 }
2382
2383 return 0;
2384 }
2385
2386 static void stlc45xx_device_release(struct device *dev)
2387 {
2388
2389 }
2390
2391 static struct platform_device stlc45xx_device = {
2392 .name = "stlc45xx",
2393 .id = -1,
2394
2395 /* device model insists to have a release function */
2396 .dev = {
2397 .release = stlc45xx_device_release,
2398 },
2399 };
2400
2401 static int __devinit stlc45xx_probe(struct spi_device *spi)
2402 {
2403 struct stlc45xx *stlc;
2404 struct ieee80211_hw *hw;
2405 int ret;
2406
2407 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2408
2409 /* mac80211 alloc */
2410 hw = ieee80211_alloc_hw(sizeof(*stlc), &stlc45xx_ops);
2411 if (!hw) {
2412 stlc45xx_error("could not alloc ieee80211_hw");
2413 ret = -ENOMEM;
2414 goto out;
2415 }
2416
2417 /* mac80211 clears hw->priv */
2418 stlc = hw->priv;
2419
2420 stlc->hw = hw;
2421 dev_set_drvdata(&spi->dev, stlc);
2422 stlc->spi = spi;
2423
2424 spi->bits_per_word = 16;
2425 spi->max_speed_hz = 24000000;
2426
2427 ret = spi_setup(spi);
2428 if (ret < 0)
2429 stlc45xx_error("spi_setup failed");
2430
2431 ret = gpio_request(stlc45xx_gpio_power, "stlc45xx power");
2432 if (ret < 0) {
2433 stlc45xx_error("power GPIO request failed: %d", ret);
2434 return ret;
2435 }
2436
2437 ret = gpio_request(stlc45xx_gpio_irq, "stlc45xx irq");
2438 if (ret < 0) {
2439 stlc45xx_error("irq GPIO request failed: %d", ret);
2440 goto out;
2441 }
2442
2443 gpio_direction_output(stlc45xx_gpio_power, 0);
2444 gpio_direction_input(stlc45xx_gpio_irq);
2445
2446 ret = request_irq(gpio_to_irq(stlc45xx_gpio_irq),
2447 stlc45xx_interrupt, IRQF_DISABLED, "stlc45xx",
2448 stlc->spi);
2449 if (ret < 0)
2450 /* FIXME: handle the error */
2451 stlc45xx_error("request_irq() failed");
2452
2453 set_irq_type(gpio_to_irq(stlc45xx_gpio_irq),
2454 IRQ_TYPE_EDGE_RISING);
2455
2456 disable_irq(gpio_to_irq(stlc45xx_gpio_irq));
2457
2458 ret = platform_device_register(&stlc45xx_device);
2459 if (ret) {
2460 stlc45xx_error("Couldn't register wlan_omap device.");
2461 return ret;
2462 }
2463 dev_set_drvdata(&stlc45xx_device.dev, stlc);
2464
2465 INIT_WORK(&stlc->work, stlc45xx_work);
2466 INIT_WORK(&stlc->work_reset, stlc45xx_work_reset);
2467 INIT_DELAYED_WORK(&stlc->work_tx_timeout, stlc45xx_work_tx_timeout);
2468 mutex_init(&stlc->mutex);
2469 init_completion(&stlc->fw_comp);
2470 spin_lock_init(&stlc->tx_lock);
2471 INIT_LIST_HEAD(&stlc->txbuffer);
2472 INIT_LIST_HEAD(&stlc->tx_pending);
2473 INIT_LIST_HEAD(&stlc->tx_sent);
2474
2475 hw->flags = IEEE80211_HW_RX_INCLUDES_FCS |
2476 IEEE80211_HW_SIGNAL_DBM |
2477 IEEE80211_HW_NOISE_DBM;
2478 /* four bytes for padding */
2479 hw->extra_tx_headroom = sizeof(struct s_lm_data_out) + 4;
2480
2481 /* unit us */
2482 hw->channel_change_time = 1000;
2483
2484 hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
2485 hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &stlc45xx_band_2ghz;
2486
2487 SET_IEEE80211_DEV(hw, &spi->dev);
2488
2489 BUILD_BUG_ON(sizeof(default_cal_rssi) != RSSI_CAL_ARRAY_LEN);
2490 BUILD_BUG_ON(sizeof(default_cal_channels) != CHANNEL_CAL_ARRAY_LEN);
2491
2492 stlc->cal_rssi = kmemdup(default_cal_rssi, RSSI_CAL_ARRAY_LEN,
2493 GFP_KERNEL);
2494 stlc->cal_channels = kmemdup(default_cal_channels,
2495 CHANNEL_CAL_ARRAY_LEN,
2496 GFP_KERNEL);
2497
2498 ret = device_create_file(&stlc45xx_device.dev, &dev_attr_cal_rssi);
2499 if (ret < 0) {
2500 stlc45xx_error("failed to create sysfs file cal_rssi");
2501 goto out;
2502 }
2503
2504 ret = device_create_file(&stlc45xx_device.dev, &dev_attr_cal_channels);
2505 if (ret < 0) {
2506 stlc45xx_error("failed to create sysfs file cal_channels");
2507 goto out;
2508 }
2509
2510 ret = device_create_file(&stlc45xx_device.dev, &dev_attr_tx_buf);
2511 if (ret < 0) {
2512 stlc45xx_error("failed to create sysfs file tx_buf");
2513 goto out;
2514 }
2515
2516 ret = stlc45xx_register_mac80211(stlc);
2517 if (ret < 0)
2518 goto out;
2519
2520 stlc45xx_info("v" DRIVER_VERSION " loaded");
2521
2522 stlc45xx_info("config buffer 0x%x-0x%x",
2523 FIRMWARE_CONFIG_START, FIRMWARE_CONFIG_END);
2524 stlc45xx_info("tx 0x%x-0x%x, rx 0x%x-0x%x",
2525 FIRMWARE_TXBUFFER_START, FIRMWARE_TXBUFFER_END,
2526 FIRMWARE_RXBUFFER_START, FIRMWARE_RXBUFFER_END);
2527
2528 out:
2529 return ret;
2530 }
2531
2532 static int __devexit stlc45xx_remove(struct spi_device *spi)
2533 {
2534 struct stlc45xx *stlc = dev_get_drvdata(&spi->dev);
2535
2536 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2537
2538 platform_device_unregister(&stlc45xx_device);
2539
2540 ieee80211_unregister_hw(stlc->hw);
2541
2542 free_irq(gpio_to_irq(stlc45xx_gpio_irq), spi);
2543
2544 gpio_free(stlc45xx_gpio_power);
2545 gpio_free(stlc45xx_gpio_irq);
2546
2547 /* FIXME: free cal_channels and cal_rssi? */
2548
2549 kfree(stlc->fw);
2550
2551 mutex_destroy(&stlc->mutex);
2552
2553 /* frees also stlc */
2554 ieee80211_free_hw(stlc->hw);
2555 stlc = NULL;
2556
2557 return 0;
2558 }
2559
2560
2561 static struct spi_driver stlc45xx_spi_driver = {
2562 .driver = {
2563 /* use cx3110x name because board-n800.c uses that for the
2564 * SPI port */
2565 .name = "cx3110x",
2566 .bus = &spi_bus_type,
2567 .owner = THIS_MODULE,
2568 },
2569
2570 .probe = stlc45xx_probe,
2571 .remove = __devexit_p(stlc45xx_remove),
2572 };
2573
2574 static int __init stlc45xx_init(void)
2575 {
2576 int ret;
2577
2578 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2579
2580 ret = spi_register_driver(&stlc45xx_spi_driver);
2581 if (ret < 0) {
2582 stlc45xx_error("failed to register SPI driver: %d", ret);
2583 goto out;
2584 }
2585
2586 out:
2587 return ret;
2588 }
2589
2590 static void __exit stlc45xx_exit(void)
2591 {
2592 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2593
2594 spi_unregister_driver(&stlc45xx_spi_driver);
2595
2596 stlc45xx_info("unloaded");
2597 }
2598
2599 module_init(stlc45xx_init);
2600 module_exit(stlc45xx_exit);
2601
2602 MODULE_LICENSE("GPL");
2603 MODULE_AUTHOR("Kalle Valo <kalle.valo@nokia.com>");
Support for the Chinese Samsung S3C2440 based development boards