?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Staging: stlc45xx: fix printk format warnings
[linux-2.6/mini2440.git] / drivers / staging / stlc45xx / stlc45xx.c
blob3eced5520c56e8d7f72ea6cb854099db58c351b5
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 DECLARE_MAC_BUF(mac);
1791 struct sk_buff *skb;
1792 char *payload;
1793 u16 fc;
1794
1795 skb = dev_alloc_skb(stlc->hw->extra_tx_headroom + 16);
1796 if (!skb) {
1797 stlc45xx_warning("failed to allocate pspoll frame");
1798 return -ENOMEM;
1799 }
1800 skb_reserve(skb, stlc->hw->extra_tx_headroom);
1801
1802 pspoll = (struct ieee80211_hdr *) skb_put(skb, 16);
1803 memset(pspoll, 0, 16);
1804 fc = IEEE80211_FTYPE_CTL | IEEE80211_STYPE_PSPOLL;
1805 if (powersave)
1806 fc |= IEEE80211_FCTL_PM;
1807 pspoll->frame_control = cpu_to_le16(fc);
1808 pspoll->duration_id = cpu_to_le16(stlc->aid);
1809
1810 /* aid in PS-Poll has its two MSBs each set to 1 */
1811 pspoll->duration_id |= cpu_to_le16(1 << 15) | cpu_to_le16(1 << 14);
1812
1813 memcpy(pspoll->addr1, stlc->bssid, ETH_ALEN);
1814 memcpy(pspoll->addr2, stlc->mac_addr, ETH_ALEN);
1815
1816 stlc45xx_debug(DEBUG_PSM, "sending PS-Poll frame to %s (powersave %d, "
1817 "fc 0x%x, aid %d)", print_mac(mac, pspoll->addr1),
1818 powersave, fc, stlc->aid);
1819
1820 spin_lock_bh(&stlc->tx_lock);
1821
1822 entry = stlc45xx_txbuffer_alloc(stlc, skb->len);
1823
1824 spin_unlock_bh(&stlc->tx_lock);
1825
1826 if (!entry) {
1827 /*
1828 * The queue should be stopped before the firmware buffer
1829 * is full, so firmware buffer should always have enough
1830 * space.
1831 *
1832 * But I'm too lazy and omit it for now.
1833 */
1834 if (net_ratelimit())
1835 stlc45xx_warning("firmware tx buffer full is full "
1836 "for null frame");
1837 return -ENOSPC;
1838 }
1839
1840 payload = skb->data;
1841 payload_len = skb->len;
1842 padding = (int) (skb->data - sizeof(*data)) & 3;
1843 entry->header_len = sizeof(*data) + padding;
1844
1845 entry->skb = skb;
1846 entry->status_needed = false;
1847 entry->handle = (u32) skb;
1848 entry->lifetime = jiffies + msecs_to_jiffies(TX_FRAME_LIFETIME);
1849
1850 stlc45xx_debug(DEBUG_TX, "tx data 0x%x (0x%p payload %d B "
1851 "padding %d header_len %d)",
1852 entry->handle, payload, payload_len, padding,
1853 entry->header_len);
1854 stlc45xx_dump(DEBUG_TX_CONTENT, payload, payload_len);
1855
1856 data = (struct s_lm_data_out *) skb_push(skb, entry->header_len);
1857
1858 memset(data, 0, entry->header_len);
1859
1860 if (padding)
1861 data->flags = LM_FLAG_ALIGN;
1862
1863 data->flags = LM_OUT_BURST;
1864 data->length = payload_len;
1865 data->handle = entry->handle;
1866 data->aid = 1;
1867 data->rts_retries = 7;
1868 data->retries = 7;
1869 data->aloft_ctrl = 0;
1870 data->crypt_offset = 58;
1871 data->keytype = 0;
1872 data->keylen = 0;
1873 data->queue = LM_QUEUE_DATA3;
1874 data->backlog = 32;
1875 data->antenna = 2;
1876 data->cts = 3;
1877 data->power = 127;
1878
1879 for (i = 0; i < 8; i++)
1880 data->aloft[i] = 0;
1881
1882 /*
1883 * check if there's enough space in tx buffer
1884 *
1885 * FIXME: ignored for now
1886 */
1887
1888 stlc45xx_tx_frame(stlc, entry->start, skb->data, skb->len);
1889
1890 list_add(&entry->tx_list, &stlc->tx_sent);
1891
1892 return 0;
1893 }
1894
1895 /*
1896 * caller must hold mutex
1897 *
1898 * shamelessly stolen from mac80211/ieee80211_send_nullfunc
1899 */
1900 static int stlc45xx_tx_nullfunc(struct stlc45xx *stlc, bool powersave)
1901 {
1902 struct ieee80211_hdr *nullfunc;
1903 int payload_len, padding, i;
1904 struct s_lm_data_out *data;
1905 struct txbuffer *entry;
1906 DECLARE_MAC_BUF(mac);
1907 struct sk_buff *skb;
1908 char *payload;
1909 u16 fc;
1910
1911 skb = dev_alloc_skb(stlc->hw->extra_tx_headroom + 24);
1912 if (!skb) {
1913 stlc45xx_warning("failed to allocate buffer for null frame\n");
1914 return -ENOMEM;
1915 }
1916 skb_reserve(skb, stlc->hw->extra_tx_headroom);
1917
1918 nullfunc = (struct ieee80211_hdr *) skb_put(skb, 24);
1919 memset(nullfunc, 0, 24);
1920 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |
1921 IEEE80211_FCTL_TODS;
1922
1923 if (powersave)
1924 fc |= IEEE80211_FCTL_PM;
1925
1926 nullfunc->frame_control = cpu_to_le16(fc);
1927 memcpy(nullfunc->addr1, stlc->bssid, ETH_ALEN);
1928 memcpy(nullfunc->addr2, stlc->mac_addr, ETH_ALEN);
1929 memcpy(nullfunc->addr3, stlc->bssid, ETH_ALEN);
1930
1931 stlc45xx_debug(DEBUG_PSM, "sending Null frame to %s (powersave %d, "
1932 "fc 0x%x)",
1933 print_mac(mac, nullfunc->addr1), powersave, fc);
1934
1935 spin_lock_bh(&stlc->tx_lock);
1936
1937 entry = stlc45xx_txbuffer_alloc(stlc, skb->len);
1938
1939 spin_unlock_bh(&stlc->tx_lock);
1940
1941 if (!entry) {
1942 /*
1943 * The queue should be stopped before the firmware buffer
1944 * is full, so firmware buffer should always have enough
1945 * space.
1946 *
1947 * But I'm too lazy and omit it for now.
1948 */
1949 if (net_ratelimit())
1950 stlc45xx_warning("firmware tx buffer full is full "
1951 "for null frame");
1952 return -ENOSPC;
1953 }
1954
1955 payload = skb->data;
1956 payload_len = skb->len;
1957 padding = (int) (skb->data - sizeof(*data)) & 3;
1958 entry->header_len = sizeof(*data) + padding;
1959
1960 entry->skb = skb;
1961 entry->status_needed = false;
1962 entry->handle = (u32) skb;
1963 entry->lifetime = jiffies + msecs_to_jiffies(TX_FRAME_LIFETIME);
1964
1965 stlc45xx_debug(DEBUG_TX, "tx data 0x%x (0x%p payload %d B "
1966 "padding %d header_len %d)",
1967 entry->handle, payload, payload_len, padding,
1968 entry->header_len);
1969 stlc45xx_dump(DEBUG_TX_CONTENT, payload, payload_len);
1970
1971 data = (struct s_lm_data_out *) skb_push(skb, entry->header_len);
1972
1973 memset(data, 0, entry->header_len);
1974
1975 if (padding)
1976 data->flags = LM_FLAG_ALIGN;
1977
1978 data->flags = LM_OUT_BURST;
1979 data->length = payload_len;
1980 data->handle = entry->handle;
1981 data->aid = 1;
1982 data->rts_retries = 7;
1983 data->retries = 7;
1984 data->aloft_ctrl = 0;
1985 data->crypt_offset = 58;
1986 data->keytype = 0;
1987 data->keylen = 0;
1988 data->queue = LM_QUEUE_DATA3;
1989 data->backlog = 32;
1990 data->antenna = 2;
1991 data->cts = 3;
1992 data->power = 127;
1993
1994 for (i = 0; i < 8; i++)
1995 data->aloft[i] = 0;
1996
1997 /*
1998 * check if there's enough space in tx buffer
1999 *
2000 * FIXME: ignored for now
2001 */
2002
2003 stlc45xx_tx_frame(stlc, entry->start, skb->data, skb->len);
2004
2005 list_add(&entry->tx_list, &stlc->tx_sent);
2006
2007 return 0;
2008 }
2009
2010 /* caller must hold mutex */
2011 static void stlc45xx_tx_psm(struct stlc45xx *stlc, bool enable)
2012 {
2013 struct s_lm_control *control;
2014 struct s_lmo_psm *psm;
2015 size_t len, psm_len;
2016
2017 WARN_ON(!stlc->associated);
2018 WARN_ON(stlc->aid < 1);
2019 WARN_ON(stlc->aid > 2007);
2020
2021 psm_len = sizeof(*psm);
2022 len = sizeof(*control) + psm_len;
2023 control = kzalloc(len, GFP_KERNEL);
2024 psm = (struct s_lmo_psm *) (control + 1);
2025
2026 control->flags = LM_FLAG_CONTROL | LM_CTRL_OPSET;
2027 control->length = psm_len;
2028 control->oid = LM_OID_PSM;
2029
2030 if (enable)
2031 psm->flags |= LM_PSM;
2032
2033 psm->aid = stlc->aid;
2034
2035 psm->beacon_rcpi_skip_max = 60;
2036
2037 psm->intervals[0].interval = 1;
2038 psm->intervals[0].periods = 1;
2039 psm->intervals[1].interval = 1;
2040 psm->intervals[1].periods = 1;
2041 psm->intervals[2].interval = 1;
2042 psm->intervals[2].periods = 1;
2043 psm->intervals[3].interval = 1;
2044 psm->intervals[3].periods = 1;
2045
2046 psm->nr = 0;
2047 psm->exclude[0] = 0;
2048
2049 stlc45xx_debug(DEBUG_PSM, "sending LM_OID_PSM (aid %d, interval %d)",
2050 psm->aid, psm->intervals[0].interval);
2051
2052 stlc45xx_tx_frame(stlc, FIRMWARE_CONFIG_START, control, len);
2053
2054 kfree(control);
2055 }
2056
2057 static int stlc45xx_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
2058 {
2059 struct stlc45xx *stlc = hw->priv;
2060 struct ieee80211_tx_info *info;
2061 struct ieee80211_rate *rate;
2062 int payload_len, padding, i;
2063 struct s_lm_data_out *data;
2064 struct txbuffer *entry;
2065 char *payload;
2066
2067 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2068
2069 spin_lock_bh(&stlc->tx_lock);
2070
2071 entry = stlc45xx_txbuffer_alloc(stlc, skb->len);
2072 if (!entry) {
2073 /* the queue should be stopped before the firmware buffer
2074 * is full, so firmware buffer should always have enough
2075 * space */
2076 if (net_ratelimit())
2077 stlc45xx_warning("firmware buffer full");
2078 spin_unlock_bh(&stlc->tx_lock);
2079 return NETDEV_TX_BUSY;
2080 }
2081
2082 info = IEEE80211_SKB_CB(skb);
2083
2084 payload = skb->data;
2085 payload_len = skb->len;
2086 padding = (int) (skb->data - sizeof(*data)) & 3;
2087 entry->header_len = sizeof(*data) + padding;
2088
2089 entry->skb = skb;
2090 entry->status_needed = true;
2091 entry->handle = (u32) skb;
2092 entry->lifetime = jiffies + msecs_to_jiffies(TX_FRAME_LIFETIME);
2093
2094 stlc45xx_debug(DEBUG_TX, "tx data 0x%x (0x%p payload %d B "
2095 "padding %d header_len %d)",
2096 entry->handle, payload, payload_len, padding,
2097 entry->header_len);
2098 stlc45xx_dump(DEBUG_TX_CONTENT, payload, payload_len);
2099
2100 data = (struct s_lm_data_out *) skb_push(skb, entry->header_len);
2101
2102 memset(data, 0, entry->header_len);
2103
2104 if (padding)
2105 data->flags = LM_FLAG_ALIGN;
2106
2107 data->flags = LM_OUT_BURST;
2108 data->length = payload_len;
2109 data->handle = entry->handle;
2110 data->aid = 1;
2111 data->rts_retries = 7;
2112 data->retries = 7;
2113 data->aloft_ctrl = 0;
2114 data->crypt_offset = 58;
2115 data->keytype = 0;
2116 data->keylen = 0;
2117 data->queue = 2;
2118 data->backlog = 32;
2119 data->antenna = 2;
2120 data->cts = 3;
2121 data->power = 127;
2122
2123 for (i = 0; i < 8; i++) {
2124 rate = ieee80211_get_tx_rate(stlc->hw, info);
2125 data->aloft[i] = rate->hw_value;
2126 }
2127
2128 list_add_tail(&entry->tx_list, &stlc->tx_pending);
2129
2130 /* check if there's enough space in tx buffer */
2131 if (stlc45xx_txbuffer_find(stlc, MAX_FRAME_LEN) == -1) {
2132 stlc45xx_debug(DEBUG_QUEUE, "tx buffer full, stopping queues");
2133 stlc->tx_queue_stopped = 1;
2134 ieee80211_stop_queues(stlc->hw);
2135 }
2136
2137 queue_work(stlc->hw->workqueue, &stlc->work);
2138
2139 spin_unlock_bh(&stlc->tx_lock);
2140
2141 return NETDEV_TX_OK;
2142 }
2143
2144 static int stlc45xx_op_start(struct ieee80211_hw *hw)
2145 {
2146 struct stlc45xx *stlc = hw->priv;
2147 unsigned long timeout;
2148 int ret = 0;
2149
2150 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2151
2152 mutex_lock(&stlc->mutex);
2153
2154 stlc->fw_state = FW_STATE_BOOTING;
2155 stlc->channel = 1;
2156
2157 stlc45xx_power_on(stlc);
2158
2159 ret = stlc45xx_upload_firmware(stlc);
2160 if (ret < 0) {
2161 stlc45xx_power_off(stlc);
2162 goto out_unlock;
2163 }
2164
2165 stlc->tx_queue_stopped = 0;
2166
2167 mutex_unlock(&stlc->mutex);
2168
2169 timeout = msecs_to_jiffies(2000);
2170 timeout = wait_for_completion_interruptible_timeout(&stlc->fw_comp,
2171 timeout);
2172 if (!timeout) {
2173 stlc45xx_error("firmware boot failed");
2174 stlc45xx_power_off(stlc);
2175 ret = -1;
2176 goto out;
2177 }
2178
2179 stlc45xx_debug(DEBUG_BOOT, "firmware booted");
2180
2181 /* FIXME: should we take mutex just after wait_for_completion()? */
2182 mutex_lock(&stlc->mutex);
2183
2184 WARN_ON(stlc->fw_state != FW_STATE_READY);
2185
2186 out_unlock:
2187 mutex_unlock(&stlc->mutex);
2188
2189 out:
2190 return ret;
2191 }
2192
2193 static void stlc45xx_op_stop(struct ieee80211_hw *hw)
2194 {
2195 struct stlc45xx *stlc = hw->priv;
2196
2197 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2198
2199 mutex_lock(&stlc->mutex);
2200
2201 WARN_ON(stlc->fw_state != FW_STATE_READY);
2202
2203 stlc45xx_power_off(stlc);
2204
2205 /* FIXME: make sure that all work_structs have completed */
2206
2207 spin_lock_bh(&stlc->tx_lock);
2208 stlc45xx_flush_queues(stlc);
2209 spin_unlock_bh(&stlc->tx_lock);
2210
2211 stlc->fw_state = FW_STATE_OFF;
2212
2213 mutex_unlock(&stlc->mutex);
2214 }
2215
2216 static int stlc45xx_op_add_interface(struct ieee80211_hw *hw,
2217 struct ieee80211_if_init_conf *conf)
2218 {
2219 struct stlc45xx *stlc = hw->priv;
2220
2221 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2222
2223 switch (conf->type) {
2224 case NL80211_IFTYPE_STATION:
2225 break;
2226 default:
2227 return -EOPNOTSUPP;
2228 }
2229
2230 memcpy(stlc->mac_addr, conf->mac_addr, ETH_ALEN);
2231
2232 return 0;
2233 }
2234
2235 static void stlc45xx_op_remove_interface(struct ieee80211_hw *hw,
2236 struct ieee80211_if_init_conf *conf)
2237 {
2238 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2239 }
2240
2241 static int stlc45xx_op_config_interface(struct ieee80211_hw *hw,
2242 struct ieee80211_vif *vif,
2243 struct ieee80211_if_conf *conf)
2244 {
2245 struct stlc45xx *stlc = hw->priv;
2246
2247 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2248
2249 mutex_lock(&stlc->mutex);
2250
2251 memcpy(stlc->bssid, conf->bssid, ETH_ALEN);
2252 stlc45xx_tx_setup(stlc);
2253
2254 mutex_unlock(&stlc->mutex);
2255
2256 return 0;
2257 }
2258
2259 static int stlc45xx_op_config(struct ieee80211_hw *hw, u32 changed)
2260 {
2261 struct stlc45xx *stlc = hw->priv;
2262
2263 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2264
2265 mutex_lock(&stlc->mutex);
2266
2267 stlc->channel = hw->conf.channel->hw_value;
2268 stlc45xx_tx_scan(stlc);
2269 stlc45xx_tx_setup(stlc);
2270 stlc45xx_tx_edcf(stlc);
2271
2272 if ((hw->conf.flags & IEEE80211_CONF_PS) != stlc->psm) {
2273 stlc->psm = hw->conf.flags & IEEE80211_CONF_PS;
2274 if (stlc->associated) {
2275 stlc45xx_tx_psm(stlc, stlc->psm);
2276 stlc45xx_tx_nullfunc(stlc, stlc->psm);
2277 }
2278 }
2279
2280 mutex_unlock(&stlc->mutex);
2281
2282 return 0;
2283 }
2284
2285 static void stlc45xx_op_configure_filter(struct ieee80211_hw *hw,
2286 unsigned int changed_flags,
2287 unsigned int *total_flags,
2288 int mc_count,
2289 struct dev_addr_list *mc_list)
2290 {
2291 *total_flags = 0;
2292 }
2293
2294 static void stlc45xx_op_bss_info_changed(struct ieee80211_hw *hw,
2295 struct ieee80211_vif *vif,
2296 struct ieee80211_bss_conf *info,
2297 u32 changed)
2298 {
2299 struct stlc45xx *stlc = hw->priv;
2300
2301 if (changed & BSS_CHANGED_ASSOC) {
2302 stlc->associated = info->assoc;
2303 if (info->assoc)
2304 stlc->aid = info->aid;
2305 else
2306 stlc->aid = -1;
2307
2308 if (stlc->psm) {
2309 stlc45xx_tx_psm(stlc, stlc->psm);
2310 stlc45xx_tx_nullfunc(stlc, stlc->psm);
2311 }
2312 }
2313 }
2314
2315
2316 /* can't be const, mac80211 writes to this */
2317 static struct ieee80211_rate stlc45xx_rates[] = {
2318 { .bitrate = 10, .hw_value = 0, .hw_value_short = 0, },
2319 { .bitrate = 20, .hw_value = 1, .hw_value_short = 1, },
2320 { .bitrate = 55, .hw_value = 2, .hw_value_short = 2, },
2321 { .bitrate = 110, .hw_value = 3, .hw_value_short = 3, },
2322 { .bitrate = 60, .hw_value = 4, .hw_value_short = 4, },
2323 { .bitrate = 90, .hw_value = 5, .hw_value_short = 5, },
2324 { .bitrate = 120, .hw_value = 6, .hw_value_short = 6, },
2325 { .bitrate = 180, .hw_value = 7, .hw_value_short = 7, },
2326 { .bitrate = 240, .hw_value = 8, .hw_value_short = 8, },
2327 { .bitrate = 360, .hw_value = 9, .hw_value_short = 9, },
2328 { .bitrate = 480, .hw_value = 10, .hw_value_short = 10, },
2329 { .bitrate = 540, .hw_value = 11, .hw_value_short = 11, },
2330 };
2331
2332 /* can't be const, mac80211 writes to this */
2333 static struct ieee80211_channel stlc45xx_channels[] = {
2334 { .hw_value = 1, .center_freq = 2412},
2335 { .hw_value = 2, .center_freq = 2417},
2336 { .hw_value = 3, .center_freq = 2422},
2337 { .hw_value = 4, .center_freq = 2427},
2338 { .hw_value = 5, .center_freq = 2432},
2339 { .hw_value = 6, .center_freq = 2437},
2340 { .hw_value = 7, .center_freq = 2442},
2341 { .hw_value = 8, .center_freq = 2447},
2342 { .hw_value = 9, .center_freq = 2452},
2343 { .hw_value = 10, .center_freq = 2457},
2344 { .hw_value = 11, .center_freq = 2462},
2345 { .hw_value = 12, .center_freq = 2467},
2346 { .hw_value = 13, .center_freq = 2472},
2347 };
2348
2349 /* can't be const, mac80211 writes to this */
2350 static struct ieee80211_supported_band stlc45xx_band_2ghz = {
2351 .channels = stlc45xx_channels,
2352 .n_channels = ARRAY_SIZE(stlc45xx_channels),
2353 .bitrates = stlc45xx_rates,
2354 .n_bitrates = ARRAY_SIZE(stlc45xx_rates),
2355 };
2356
2357 static const struct ieee80211_ops stlc45xx_ops = {
2358 .start = stlc45xx_op_start,
2359 .stop = stlc45xx_op_stop,
2360 .add_interface = stlc45xx_op_add_interface,
2361 .remove_interface = stlc45xx_op_remove_interface,
2362 .config = stlc45xx_op_config,
2363 .config_interface = stlc45xx_op_config_interface,
2364 .configure_filter = stlc45xx_op_configure_filter,
2365 .tx = stlc45xx_op_tx,
2366 .bss_info_changed = stlc45xx_op_bss_info_changed,
2367 };
2368
2369 static int stlc45xx_register_mac80211(struct stlc45xx *stlc)
2370 {
2371 /* FIXME: SET_IEEE80211_PERM_ADDR() requires default_mac_addr
2372 to be non-const for some strange reason */
2373 static u8 default_mac_addr[ETH_ALEN] = {
2374 0x00, 0x02, 0xee, 0xc0, 0xff, 0xee
2375 };
2376 int ret;
2377
2378 SET_IEEE80211_PERM_ADDR(stlc->hw, default_mac_addr);
2379
2380 ret = ieee80211_register_hw(stlc->hw);
2381 if (ret) {
2382 stlc45xx_error("unable to register mac80211 hw: %d", ret);
2383 return ret;
2384 }
2385
2386 return 0;
2387 }
2388
2389 static void stlc45xx_device_release(struct device *dev)
2390 {
2391
2392 }
2393
2394 static struct platform_device stlc45xx_device = {
2395 .name = "stlc45xx",
2396 .id = -1,
2397
2398 /* device model insists to have a release function */
2399 .dev = {
2400 .release = stlc45xx_device_release,
2401 },
2402 };
2403
2404 static int __devinit stlc45xx_probe(struct spi_device *spi)
2405 {
2406 struct stlc45xx *stlc;
2407 struct ieee80211_hw *hw;
2408 int ret;
2409
2410 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2411
2412 /* mac80211 alloc */
2413 hw = ieee80211_alloc_hw(sizeof(*stlc), &stlc45xx_ops);
2414 if (!hw) {
2415 stlc45xx_error("could not alloc ieee80211_hw");
2416 ret = -ENOMEM;
2417 goto out;
2418 }
2419
2420 /* mac80211 clears hw->priv */
2421 stlc = hw->priv;
2422
2423 stlc->hw = hw;
2424 dev_set_drvdata(&spi->dev, stlc);
2425 stlc->spi = spi;
2426
2427 spi->bits_per_word = 16;
2428 spi->max_speed_hz = 24000000;
2429
2430 ret = spi_setup(spi);
2431 if (ret < 0)
2432 stlc45xx_error("spi_setup failed");
2433
2434 ret = gpio_request(stlc45xx_gpio_power, "stlc45xx power");
2435 if (ret < 0) {
2436 stlc45xx_error("power GPIO request failed: %d", ret);
2437 return ret;
2438 }
2439
2440 ret = gpio_request(stlc45xx_gpio_irq, "stlc45xx irq");
2441 if (ret < 0) {
2442 stlc45xx_error("irq GPIO request failed: %d", ret);
2443 goto out;
2444 }
2445
2446 gpio_direction_output(stlc45xx_gpio_power, 0);
2447 gpio_direction_input(stlc45xx_gpio_irq);
2448
2449 ret = request_irq(gpio_to_irq(stlc45xx_gpio_irq),
2450 stlc45xx_interrupt, IRQF_DISABLED, "stlc45xx",
2451 stlc->spi);
2452 if (ret < 0)
2453 /* FIXME: handle the error */
2454 stlc45xx_error("request_irq() failed");
2455
2456 set_irq_type(gpio_to_irq(stlc45xx_gpio_irq),
2457 IRQ_TYPE_EDGE_RISING);
2458
2459 disable_irq(gpio_to_irq(stlc45xx_gpio_irq));
2460
2461 ret = platform_device_register(&stlc45xx_device);
2462 if (ret) {
2463 stlc45xx_error("Couldn't register wlan_omap device.");
2464 return ret;
2465 }
2466 dev_set_drvdata(&stlc45xx_device.dev, stlc);
2467
2468 INIT_WORK(&stlc->work, stlc45xx_work);
2469 INIT_WORK(&stlc->work_reset, stlc45xx_work_reset);
2470 INIT_DELAYED_WORK(&stlc->work_tx_timeout, stlc45xx_work_tx_timeout);
2471 mutex_init(&stlc->mutex);
2472 init_completion(&stlc->fw_comp);
2473 spin_lock_init(&stlc->tx_lock);
2474 INIT_LIST_HEAD(&stlc->txbuffer);
2475 INIT_LIST_HEAD(&stlc->tx_pending);
2476 INIT_LIST_HEAD(&stlc->tx_sent);
2477
2478 hw->flags = IEEE80211_HW_RX_INCLUDES_FCS |
2479 IEEE80211_HW_SIGNAL_DBM |
2480 IEEE80211_HW_NOISE_DBM;
2481 /* four bytes for padding */
2482 hw->extra_tx_headroom = sizeof(struct s_lm_data_out) + 4;
2483
2484 /* unit us */
2485 hw->channel_change_time = 1000;
2486
2487 hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
2488 hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &stlc45xx_band_2ghz;
2489
2490 SET_IEEE80211_DEV(hw, &spi->dev);
2491
2492 BUILD_BUG_ON(sizeof(default_cal_rssi) != RSSI_CAL_ARRAY_LEN);
2493 BUILD_BUG_ON(sizeof(default_cal_channels) != CHANNEL_CAL_ARRAY_LEN);
2494
2495 stlc->cal_rssi = kmemdup(default_cal_rssi, RSSI_CAL_ARRAY_LEN,
2496 GFP_KERNEL);
2497 stlc->cal_channels = kmemdup(default_cal_channels,
2498 CHANNEL_CAL_ARRAY_LEN,
2499 GFP_KERNEL);
2500
2501 ret = device_create_file(&stlc45xx_device.dev, &dev_attr_cal_rssi);
2502 if (ret < 0) {
2503 stlc45xx_error("failed to create sysfs file cal_rssi");
2504 goto out;
2505 }
2506
2507 ret = device_create_file(&stlc45xx_device.dev, &dev_attr_cal_channels);
2508 if (ret < 0) {
2509 stlc45xx_error("failed to create sysfs file cal_channels");
2510 goto out;
2511 }
2512
2513 ret = device_create_file(&stlc45xx_device.dev, &dev_attr_tx_buf);
2514 if (ret < 0) {
2515 stlc45xx_error("failed to create sysfs file tx_buf");
2516 goto out;
2517 }
2518
2519 ret = stlc45xx_register_mac80211(stlc);
2520 if (ret < 0)
2521 goto out;
2522
2523 stlc45xx_info("v" DRIVER_VERSION " loaded");
2524
2525 stlc45xx_info("config buffer 0x%x-0x%x",
2526 FIRMWARE_CONFIG_START, FIRMWARE_CONFIG_END);
2527 stlc45xx_info("tx 0x%x-0x%x, rx 0x%x-0x%x",
2528 FIRMWARE_TXBUFFER_START, FIRMWARE_TXBUFFER_END,
2529 FIRMWARE_RXBUFFER_START, FIRMWARE_RXBUFFER_END);
2530
2531 out:
2532 return ret;
2533 }
2534
2535 static int __devexit stlc45xx_remove(struct spi_device *spi)
2536 {
2537 struct stlc45xx *stlc = dev_get_drvdata(&spi->dev);
2538
2539 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2540
2541 platform_device_unregister(&stlc45xx_device);
2542
2543 ieee80211_unregister_hw(stlc->hw);
2544
2545 free_irq(gpio_to_irq(stlc45xx_gpio_irq), spi);
2546
2547 gpio_free(stlc45xx_gpio_power);
2548 gpio_free(stlc45xx_gpio_irq);
2549
2550 /* FIXME: free cal_channels and cal_rssi? */
2551
2552 kfree(stlc->fw);
2553
2554 mutex_destroy(&stlc->mutex);
2555
2556 /* frees also stlc */
2557 ieee80211_free_hw(stlc->hw);
2558 stlc = NULL;
2559
2560 return 0;
2561 }
2562
2563
2564 static struct spi_driver stlc45xx_spi_driver = {
2565 .driver = {
2566 /* use cx3110x name because board-n800.c uses that for the
2567 * SPI port */
2568 .name = "cx3110x",
2569 .bus = &spi_bus_type,
2570 .owner = THIS_MODULE,
2571 },
2572
2573 .probe = stlc45xx_probe,
2574 .remove = __devexit_p(stlc45xx_remove),
2575 };
2576
2577 static int __init stlc45xx_init(void)
2578 {
2579 int ret;
2580
2581 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2582
2583 ret = spi_register_driver(&stlc45xx_spi_driver);
2584 if (ret < 0) {
2585 stlc45xx_error("failed to register SPI driver: %d", ret);
2586 goto out;
2587 }
2588
2589 out:
2590 return ret;
2591 }
2592
2593 static void __exit stlc45xx_exit(void)
2594 {
2595 stlc45xx_debug(DEBUG_FUNC, "%s", __func__);
2596
2597 spi_unregister_driver(&stlc45xx_spi_driver);
2598
2599 stlc45xx_info("unloaded");
2600 }
2601
2602 module_init(stlc45xx_init);
2603 module_exit(stlc45xx_exit);
2604
2605 MODULE_LICENSE("GPL");
2606 MODULE_AUTHOR("Kalle Valo <kalle.valo@nokia.com>");
Support for the Chinese Samsung S3C2440 based development boards