Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit cc74998618a66d34651c784dd02412614c3e81cc

Authored by Jean Pihet
Committed by Rafael J. Wysocki
1 parent e8db0be124
Exists in master and in 6 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

PM QoS: Minor clean-ups 

- Misc fixes to improve code readability:
  * rename struct pm_qos_request_list to struct pm_qos_request,
  * rename pm_qos_req parameter to req in internal code,
    consistenly use req in the API parameters,
  * update the in-kernel API callers to the new parameters names,
  * rename of fields names (requests, list, node, constraints)

Signed-off-by: Jean Pihet <j-pihet@ti.com>
Acked-by: markgross <markgross@thegnar.org>
Reviewed-by: Kevin Hilman <khilman@ti.com>
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>

Showing 6 changed files with 59 additions and 59 deletions Inline Diff

drivers/media/video/via-camera.c
Diff comments   View file @ cc74998
1 /* 1 /*
2 * Driver for the VIA Chrome integrated camera controller. 2 * Driver for the VIA Chrome integrated camera controller.
3 * 3 *
4 * Copyright 2009,2010 Jonathan Corbet <corbet@lwn.net> 4 * Copyright 2009,2010 Jonathan Corbet <corbet@lwn.net>
5 * Distributable under the terms of the GNU General Public License, version 2 5 * Distributable under the terms of the GNU General Public License, version 2
6 * 6 *
7 * This work was supported by the One Laptop Per Child project 7 * This work was supported by the One Laptop Per Child project
8 */ 8 */
9 #include <linux/kernel.h> 9 #include <linux/kernel.h>
10 #include <linux/module.h> 10 #include <linux/module.h>
11 #include <linux/device.h> 11 #include <linux/device.h>
12 #include <linux/list.h> 12 #include <linux/list.h>
13 #include <linux/pci.h> 13 #include <linux/pci.h>
14 #include <linux/gpio.h> 14 #include <linux/gpio.h>
15 #include <linux/interrupt.h> 15 #include <linux/interrupt.h>
16 #include <linux/platform_device.h> 16 #include <linux/platform_device.h>
17 #include <linux/videodev2.h> 17 #include <linux/videodev2.h>
18 #include <media/v4l2-device.h> 18 #include <media/v4l2-device.h>
19 #include <media/v4l2-ioctl.h> 19 #include <media/v4l2-ioctl.h>
20 #include <media/v4l2-chip-ident.h> 20 #include <media/v4l2-chip-ident.h>
21 #include <media/videobuf-dma-sg.h> 21 #include <media/videobuf-dma-sg.h>
22 #include <linux/delay.h> 22 #include <linux/delay.h>
23 #include <linux/dma-mapping.h> 23 #include <linux/dma-mapping.h>
24 #include <linux/pm_qos.h> 24 #include <linux/pm_qos.h>
25 #include <linux/via-core.h> 25 #include <linux/via-core.h>
26 #include <linux/via-gpio.h> 26 #include <linux/via-gpio.h>
27 #include <linux/via_i2c.h> 27 #include <linux/via_i2c.h>
28 #include <asm/olpc.h> 28 #include <asm/olpc.h>
29 29
30 #include "via-camera.h" 30 #include "via-camera.h"
31 31
32 MODULE_ALIAS("platform:viafb-camera"); 32 MODULE_ALIAS("platform:viafb-camera");
33 MODULE_AUTHOR("Jonathan Corbet <corbet@lwn.net>"); 33 MODULE_AUTHOR("Jonathan Corbet <corbet@lwn.net>");
34 MODULE_DESCRIPTION("VIA framebuffer-based camera controller driver"); 34 MODULE_DESCRIPTION("VIA framebuffer-based camera controller driver");
35 MODULE_LICENSE("GPL"); 35 MODULE_LICENSE("GPL");
36 36
37 static int flip_image; 37 static int flip_image;
38 module_param(flip_image, bool, 0444); 38 module_param(flip_image, bool, 0444);
39 MODULE_PARM_DESC(flip_image, 39 MODULE_PARM_DESC(flip_image,
40 "If set, the sensor will be instructed to flip the image " 40 "If set, the sensor will be instructed to flip the image "
41 "vertically."); 41 "vertically.");
42 42
43 static int override_serial; 43 static int override_serial;
44 module_param(override_serial, bool, 0444); 44 module_param(override_serial, bool, 0444);
45 MODULE_PARM_DESC(override_serial, 45 MODULE_PARM_DESC(override_serial,
46 "The camera driver will normally refuse to load if " 46 "The camera driver will normally refuse to load if "
47 "the XO 1.5 serial port is enabled. Set this option " 47 "the XO 1.5 serial port is enabled. Set this option "
48 "to force-enable the camera."); 48 "to force-enable the camera.");
49 49
50 /* 50 /*
51 * Basic window sizes. 51 * Basic window sizes.
52 */ 52 */
53 #define VGA_WIDTH 640 53 #define VGA_WIDTH 640
54 #define VGA_HEIGHT 480 54 #define VGA_HEIGHT 480
55 #define QCIF_WIDTH 176 55 #define QCIF_WIDTH 176
56 #define QCIF_HEIGHT 144 56 #define QCIF_HEIGHT 144
57 57
58 /* 58 /*
59 * The structure describing our camera. 59 * The structure describing our camera.
60 */ 60 */
61 enum viacam_opstate { S_IDLE = 0, S_RUNNING = 1 }; 61 enum viacam_opstate { S_IDLE = 0, S_RUNNING = 1 };
62 62
63 struct via_camera { 63 struct via_camera {
64 struct v4l2_device v4l2_dev; 64 struct v4l2_device v4l2_dev;
65 struct video_device vdev; 65 struct video_device vdev;
66 struct v4l2_subdev *sensor; 66 struct v4l2_subdev *sensor;
67 struct platform_device *platdev; 67 struct platform_device *platdev;
68 struct viafb_dev *viadev; 68 struct viafb_dev *viadev;
69 struct mutex lock; 69 struct mutex lock;
70 enum viacam_opstate opstate; 70 enum viacam_opstate opstate;
71 unsigned long flags; 71 unsigned long flags;
72 struct pm_qos_request_list qos_request; 72 struct pm_qos_request qos_request;
73 /* 73 /*
74 * GPIO info for power/reset management 74 * GPIO info for power/reset management
75 */ 75 */
76 int power_gpio; 76 int power_gpio;
77 int reset_gpio; 77 int reset_gpio;
78 /* 78 /*
79 * I/O memory stuff. 79 * I/O memory stuff.
80 */ 80 */
81 void __iomem *mmio; /* Where the registers live */ 81 void __iomem *mmio; /* Where the registers live */
82 void __iomem *fbmem; /* Frame buffer memory */ 82 void __iomem *fbmem; /* Frame buffer memory */
83 u32 fb_offset; /* Reserved memory offset (FB) */ 83 u32 fb_offset; /* Reserved memory offset (FB) */
84 /* 84 /*
85 * Capture buffers and related. The controller supports 85 * Capture buffers and related. The controller supports
86 * up to three, so that's what we have here. These buffers 86 * up to three, so that's what we have here. These buffers
87 * live in frame buffer memory, so we don't call them "DMA". 87 * live in frame buffer memory, so we don't call them "DMA".
88 */ 88 */
89 unsigned int cb_offsets[3]; /* offsets into fb mem */ 89 unsigned int cb_offsets[3]; /* offsets into fb mem */
90 u8 *cb_addrs[3]; /* Kernel-space addresses */ 90 u8 *cb_addrs[3]; /* Kernel-space addresses */
91 int n_cap_bufs; /* How many are we using? */ 91 int n_cap_bufs; /* How many are we using? */
92 int next_buf; 92 int next_buf;
93 struct videobuf_queue vb_queue; 93 struct videobuf_queue vb_queue;
94 struct list_head buffer_queue; /* prot. by reg_lock */ 94 struct list_head buffer_queue; /* prot. by reg_lock */
95 /* 95 /*
96 * User tracking. 96 * User tracking.
97 */ 97 */
98 int users; 98 int users;
99 struct file *owner; 99 struct file *owner;
100 /* 100 /*
101 * Video format information. sensor_format is kept in a form 101 * Video format information. sensor_format is kept in a form
102 * that we can use to pass to the sensor. We always run the 102 * that we can use to pass to the sensor. We always run the
103 * sensor in VGA resolution, though, and let the controller 103 * sensor in VGA resolution, though, and let the controller
104 * downscale things if need be. So we keep the "real* 104 * downscale things if need be. So we keep the "real*
105 * dimensions separately. 105 * dimensions separately.
106 */ 106 */
107 struct v4l2_pix_format sensor_format; 107 struct v4l2_pix_format sensor_format;
108 struct v4l2_pix_format user_format; 108 struct v4l2_pix_format user_format;
109 enum v4l2_mbus_pixelcode mbus_code; 109 enum v4l2_mbus_pixelcode mbus_code;
110 }; 110 };
111 111
112 /* 112 /*
113 * Yes, this is a hack, but there's only going to be one of these 113 * Yes, this is a hack, but there's only going to be one of these
114 * on any system we know of. 114 * on any system we know of.
115 */ 115 */
116 static struct via_camera *via_cam_info; 116 static struct via_camera *via_cam_info;
117 117
118 /* 118 /*
119 * Flag values, manipulated with bitops 119 * Flag values, manipulated with bitops
120 */ 120 */
121 #define CF_DMA_ACTIVE 0 /* A frame is incoming */ 121 #define CF_DMA_ACTIVE 0 /* A frame is incoming */
122 #define CF_CONFIG_NEEDED 1 /* Must configure hardware */ 122 #define CF_CONFIG_NEEDED 1 /* Must configure hardware */
123 123
124 124
125 /* 125 /*
126 * Nasty ugly v4l2 boilerplate. 126 * Nasty ugly v4l2 boilerplate.
127 */ 127 */
128 #define sensor_call(cam, optype, func, args...) \ 128 #define sensor_call(cam, optype, func, args...) \
129 v4l2_subdev_call(cam->sensor, optype, func, ##args) 129 v4l2_subdev_call(cam->sensor, optype, func, ##args)
130 130
131 /* 131 /*
132 * Debugging and related. 132 * Debugging and related.
133 */ 133 */
134 #define cam_err(cam, fmt, arg...) \ 134 #define cam_err(cam, fmt, arg...) \
135 dev_err(&(cam)->platdev->dev, fmt, ##arg); 135 dev_err(&(cam)->platdev->dev, fmt, ##arg);
136 #define cam_warn(cam, fmt, arg...) \ 136 #define cam_warn(cam, fmt, arg...) \
137 dev_warn(&(cam)->platdev->dev, fmt, ##arg); 137 dev_warn(&(cam)->platdev->dev, fmt, ##arg);
138 #define cam_dbg(cam, fmt, arg...) \ 138 #define cam_dbg(cam, fmt, arg...) \
139 dev_dbg(&(cam)->platdev->dev, fmt, ##arg); 139 dev_dbg(&(cam)->platdev->dev, fmt, ##arg);
140 140
141 /* 141 /*
142 * Format handling. This is ripped almost directly from Hans's changes 142 * Format handling. This is ripped almost directly from Hans's changes
143 * to cafe_ccic.c. It's a little unfortunate; until this change, we 143 * to cafe_ccic.c. It's a little unfortunate; until this change, we
144 * didn't need to know anything about the format except its byte depth; 144 * didn't need to know anything about the format except its byte depth;
145 * now this information must be managed at this level too. 145 * now this information must be managed at this level too.
146 */ 146 */
147 static struct via_format { 147 static struct via_format {
148 __u8 *desc; 148 __u8 *desc;
149 __u32 pixelformat; 149 __u32 pixelformat;
150 int bpp; /* Bytes per pixel */ 150 int bpp; /* Bytes per pixel */
151 enum v4l2_mbus_pixelcode mbus_code; 151 enum v4l2_mbus_pixelcode mbus_code;
152 } via_formats[] = { 152 } via_formats[] = {
153 { 153 {
154 .desc = "YUYV 4:2:2", 154 .desc = "YUYV 4:2:2",
155 .pixelformat = V4L2_PIX_FMT_YUYV, 155 .pixelformat = V4L2_PIX_FMT_YUYV,
156 .mbus_code = V4L2_MBUS_FMT_YUYV8_2X8, 156 .mbus_code = V4L2_MBUS_FMT_YUYV8_2X8,
157 .bpp = 2, 157 .bpp = 2,
158 }, 158 },
159 { 159 {
160 .desc = "RGB 565", 160 .desc = "RGB 565",
161 .pixelformat = V4L2_PIX_FMT_RGB565, 161 .pixelformat = V4L2_PIX_FMT_RGB565,
162 .mbus_code = V4L2_MBUS_FMT_RGB565_2X8_LE, 162 .mbus_code = V4L2_MBUS_FMT_RGB565_2X8_LE,
163 .bpp = 2, 163 .bpp = 2,
164 }, 164 },
165 /* RGB444 and Bayer should be doable, but have never been 165 /* RGB444 and Bayer should be doable, but have never been
166 tested with this driver. */ 166 tested with this driver. */
167 }; 167 };
168 #define N_VIA_FMTS ARRAY_SIZE(via_formats) 168 #define N_VIA_FMTS ARRAY_SIZE(via_formats)
169 169
170 static struct via_format *via_find_format(u32 pixelformat) 170 static struct via_format *via_find_format(u32 pixelformat)
171 { 171 {
172 unsigned i; 172 unsigned i;
173 173
174 for (i = 0; i < N_VIA_FMTS; i++) 174 for (i = 0; i < N_VIA_FMTS; i++)
175 if (via_formats[i].pixelformat == pixelformat) 175 if (via_formats[i].pixelformat == pixelformat)
176 return via_formats + i; 176 return via_formats + i;
177 /* Not found? Then return the first format. */ 177 /* Not found? Then return the first format. */
178 return via_formats; 178 return via_formats;
179 } 179 }
180 180
181 181
182 /*--------------------------------------------------------------------------*/ 182 /*--------------------------------------------------------------------------*/
183 /* 183 /*
184 * Sensor power/reset management. This piece is OLPC-specific for 184 * Sensor power/reset management. This piece is OLPC-specific for
185 * sure; other configurations will have things connected differently. 185 * sure; other configurations will have things connected differently.
186 */ 186 */
187 static int via_sensor_power_setup(struct via_camera *cam) 187 static int via_sensor_power_setup(struct via_camera *cam)
188 { 188 {
189 int ret; 189 int ret;
190 190
191 cam->power_gpio = viafb_gpio_lookup("VGPIO3"); 191 cam->power_gpio = viafb_gpio_lookup("VGPIO3");
192 cam->reset_gpio = viafb_gpio_lookup("VGPIO2"); 192 cam->reset_gpio = viafb_gpio_lookup("VGPIO2");
193 if (cam->power_gpio < 0 || cam->reset_gpio < 0) { 193 if (cam->power_gpio < 0 || cam->reset_gpio < 0) {
194 dev_err(&cam->platdev->dev, "Unable to find GPIO lines\n"); 194 dev_err(&cam->platdev->dev, "Unable to find GPIO lines\n");
195 return -EINVAL; 195 return -EINVAL;
196 } 196 }
197 ret = gpio_request(cam->power_gpio, "viafb-camera"); 197 ret = gpio_request(cam->power_gpio, "viafb-camera");
198 if (ret) { 198 if (ret) {
199 dev_err(&cam->platdev->dev, "Unable to request power GPIO\n"); 199 dev_err(&cam->platdev->dev, "Unable to request power GPIO\n");
200 return ret; 200 return ret;
201 } 201 }
202 ret = gpio_request(cam->reset_gpio, "viafb-camera"); 202 ret = gpio_request(cam->reset_gpio, "viafb-camera");
203 if (ret) { 203 if (ret) {
204 dev_err(&cam->platdev->dev, "Unable to request reset GPIO\n"); 204 dev_err(&cam->platdev->dev, "Unable to request reset GPIO\n");
205 gpio_free(cam->power_gpio); 205 gpio_free(cam->power_gpio);
206 return ret; 206 return ret;
207 } 207 }
208 gpio_direction_output(cam->power_gpio, 0); 208 gpio_direction_output(cam->power_gpio, 0);
209 gpio_direction_output(cam->reset_gpio, 0); 209 gpio_direction_output(cam->reset_gpio, 0);
210 return 0; 210 return 0;
211 } 211 }
212 212
213 /* 213 /*
214 * Power up the sensor and perform the reset dance. 214 * Power up the sensor and perform the reset dance.
215 */ 215 */
216 static void via_sensor_power_up(struct via_camera *cam) 216 static void via_sensor_power_up(struct via_camera *cam)
217 { 217 {
218 gpio_set_value(cam->power_gpio, 1); 218 gpio_set_value(cam->power_gpio, 1);
219 gpio_set_value(cam->reset_gpio, 0); 219 gpio_set_value(cam->reset_gpio, 0);
220 msleep(20); /* Probably excessive */ 220 msleep(20); /* Probably excessive */
221 gpio_set_value(cam->reset_gpio, 1); 221 gpio_set_value(cam->reset_gpio, 1);
222 msleep(20); 222 msleep(20);
223 } 223 }
224 224
225 static void via_sensor_power_down(struct via_camera *cam) 225 static void via_sensor_power_down(struct via_camera *cam)
226 { 226 {
227 gpio_set_value(cam->power_gpio, 0); 227 gpio_set_value(cam->power_gpio, 0);
228 gpio_set_value(cam->reset_gpio, 0); 228 gpio_set_value(cam->reset_gpio, 0);
229 } 229 }
230 230
231 231
232 static void via_sensor_power_release(struct via_camera *cam) 232 static void via_sensor_power_release(struct via_camera *cam)
233 { 233 {
234 via_sensor_power_down(cam); 234 via_sensor_power_down(cam);
235 gpio_free(cam->power_gpio); 235 gpio_free(cam->power_gpio);
236 gpio_free(cam->reset_gpio); 236 gpio_free(cam->reset_gpio);
237 } 237 }
238 238
239 /* --------------------------------------------------------------------------*/ 239 /* --------------------------------------------------------------------------*/
240 /* Sensor ops */ 240 /* Sensor ops */
241 241
242 /* 242 /*
243 * Manage the ov7670 "flip" bit, which needs special help. 243 * Manage the ov7670 "flip" bit, which needs special help.
244 */ 244 */
245 static int viacam_set_flip(struct via_camera *cam) 245 static int viacam_set_flip(struct via_camera *cam)
246 { 246 {
247 struct v4l2_control ctrl; 247 struct v4l2_control ctrl;
248 248
249 memset(&ctrl, 0, sizeof(ctrl)); 249 memset(&ctrl, 0, sizeof(ctrl));
250 ctrl.id = V4L2_CID_VFLIP; 250 ctrl.id = V4L2_CID_VFLIP;
251 ctrl.value = flip_image; 251 ctrl.value = flip_image;
252 return sensor_call(cam, core, s_ctrl, &ctrl); 252 return sensor_call(cam, core, s_ctrl, &ctrl);
253 } 253 }
254 254
255 /* 255 /*
256 * Configure the sensor. It's up to the caller to ensure 256 * Configure the sensor. It's up to the caller to ensure
257 * that the camera is in the correct operating state. 257 * that the camera is in the correct operating state.
258 */ 258 */
259 static int viacam_configure_sensor(struct via_camera *cam) 259 static int viacam_configure_sensor(struct via_camera *cam)
260 { 260 {
261 struct v4l2_mbus_framefmt mbus_fmt; 261 struct v4l2_mbus_framefmt mbus_fmt;
262 int ret; 262 int ret;
263 263
264 v4l2_fill_mbus_format(&mbus_fmt, &cam->sensor_format, cam->mbus_code); 264 v4l2_fill_mbus_format(&mbus_fmt, &cam->sensor_format, cam->mbus_code);
265 ret = sensor_call(cam, core, init, 0); 265 ret = sensor_call(cam, core, init, 0);
266 if (ret == 0) 266 if (ret == 0)
267 ret = sensor_call(cam, video, s_mbus_fmt, &mbus_fmt); 267 ret = sensor_call(cam, video, s_mbus_fmt, &mbus_fmt);
268 /* 268 /*
269 * OV7670 does weird things if flip is set *before* format... 269 * OV7670 does weird things if flip is set *before* format...
270 */ 270 */
271 if (ret == 0) 271 if (ret == 0)
272 ret = viacam_set_flip(cam); 272 ret = viacam_set_flip(cam);
273 return ret; 273 return ret;
274 } 274 }
275 275
276 276
277 277
278 /* --------------------------------------------------------------------------*/ 278 /* --------------------------------------------------------------------------*/
279 /* 279 /*
280 * Some simple register accessors; they assume that the lock is held. 280 * Some simple register accessors; they assume that the lock is held.
281 * 281 *
282 * Should we want to support the second capture engine, we could 282 * Should we want to support the second capture engine, we could
283 * hide the register difference by adding 0x1000 to registers in the 283 * hide the register difference by adding 0x1000 to registers in the
284 * 0x300-350 range. 284 * 0x300-350 range.
285 */ 285 */
286 static inline void viacam_write_reg(struct via_camera *cam, 286 static inline void viacam_write_reg(struct via_camera *cam,
287 int reg, int value) 287 int reg, int value)
288 { 288 {
289 iowrite32(value, cam->mmio + reg); 289 iowrite32(value, cam->mmio + reg);
290 } 290 }
291 291
292 static inline int viacam_read_reg(struct via_camera *cam, int reg) 292 static inline int viacam_read_reg(struct via_camera *cam, int reg)
293 { 293 {
294 return ioread32(cam->mmio + reg); 294 return ioread32(cam->mmio + reg);
295 } 295 }
296 296
297 static inline void viacam_write_reg_mask(struct via_camera *cam, 297 static inline void viacam_write_reg_mask(struct via_camera *cam,
298 int reg, int value, int mask) 298 int reg, int value, int mask)
299 { 299 {
300 int tmp = viacam_read_reg(cam, reg); 300 int tmp = viacam_read_reg(cam, reg);
301 301
302 tmp = (tmp & ~mask) | (value & mask); 302 tmp = (tmp & ~mask) | (value & mask);
303 viacam_write_reg(cam, reg, tmp); 303 viacam_write_reg(cam, reg, tmp);
304 } 304 }
305 305
306 306
307 /* --------------------------------------------------------------------------*/ 307 /* --------------------------------------------------------------------------*/
308 /* Interrupt management and handling */ 308 /* Interrupt management and handling */
309 309
310 static irqreturn_t viacam_quick_irq(int irq, void *data) 310 static irqreturn_t viacam_quick_irq(int irq, void *data)
311 { 311 {
312 struct via_camera *cam = data; 312 struct via_camera *cam = data;
313 irqreturn_t ret = IRQ_NONE; 313 irqreturn_t ret = IRQ_NONE;
314 int icv; 314 int icv;
315 315
316 /* 316 /*
317 * All we do here is to clear the interrupts and tell 317 * All we do here is to clear the interrupts and tell
318 * the handler thread to wake up. 318 * the handler thread to wake up.
319 */ 319 */
320 spin_lock(&cam->viadev->reg_lock); 320 spin_lock(&cam->viadev->reg_lock);
321 icv = viacam_read_reg(cam, VCR_INTCTRL); 321 icv = viacam_read_reg(cam, VCR_INTCTRL);
322 if (icv & VCR_IC_EAV) { 322 if (icv & VCR_IC_EAV) {
323 icv |= VCR_IC_EAV|VCR_IC_EVBI|VCR_IC_FFULL; 323 icv |= VCR_IC_EAV|VCR_IC_EVBI|VCR_IC_FFULL;
324 viacam_write_reg(cam, VCR_INTCTRL, icv); 324 viacam_write_reg(cam, VCR_INTCTRL, icv);
325 ret = IRQ_WAKE_THREAD; 325 ret = IRQ_WAKE_THREAD;
326 } 326 }
327 spin_unlock(&cam->viadev->reg_lock); 327 spin_unlock(&cam->viadev->reg_lock);
328 return ret; 328 return ret;
329 } 329 }
330 330
331 /* 331 /*
332 * Find the next videobuf buffer which has somebody waiting on it. 332 * Find the next videobuf buffer which has somebody waiting on it.
333 */ 333 */
334 static struct videobuf_buffer *viacam_next_buffer(struct via_camera *cam) 334 static struct videobuf_buffer *viacam_next_buffer(struct via_camera *cam)
335 { 335 {
336 unsigned long flags; 336 unsigned long flags;
337 struct videobuf_buffer *buf = NULL; 337 struct videobuf_buffer *buf = NULL;
338 338
339 spin_lock_irqsave(&cam->viadev->reg_lock, flags); 339 spin_lock_irqsave(&cam->viadev->reg_lock, flags);
340 if (cam->opstate != S_RUNNING) 340 if (cam->opstate != S_RUNNING)
341 goto out; 341 goto out;
342 if (list_empty(&cam->buffer_queue)) 342 if (list_empty(&cam->buffer_queue))
343 goto out; 343 goto out;
344 buf = list_entry(cam->buffer_queue.next, struct videobuf_buffer, queue); 344 buf = list_entry(cam->buffer_queue.next, struct videobuf_buffer, queue);
345 if (!waitqueue_active(&buf->done)) {/* Nobody waiting */ 345 if (!waitqueue_active(&buf->done)) {/* Nobody waiting */
346 buf = NULL; 346 buf = NULL;
347 goto out; 347 goto out;
348 } 348 }
349 list_del(&buf->queue); 349 list_del(&buf->queue);
350 buf->state = VIDEOBUF_ACTIVE; 350 buf->state = VIDEOBUF_ACTIVE;
351 out: 351 out:
352 spin_unlock_irqrestore(&cam->viadev->reg_lock, flags); 352 spin_unlock_irqrestore(&cam->viadev->reg_lock, flags);
353 return buf; 353 return buf;
354 } 354 }
355 355
356 /* 356 /*
357 * The threaded IRQ handler. 357 * The threaded IRQ handler.
358 */ 358 */
359 static irqreturn_t viacam_irq(int irq, void *data) 359 static irqreturn_t viacam_irq(int irq, void *data)
360 { 360 {
361 int bufn; 361 int bufn;
362 struct videobuf_buffer *vb; 362 struct videobuf_buffer *vb;
363 struct via_camera *cam = data; 363 struct via_camera *cam = data;
364 struct videobuf_dmabuf *vdma; 364 struct videobuf_dmabuf *vdma;
365 365
366 /* 366 /*
367 * If there is no place to put the data frame, don't bother 367 * If there is no place to put the data frame, don't bother
368 * with anything else. 368 * with anything else.
369 */ 369 */
370 vb = viacam_next_buffer(cam); 370 vb = viacam_next_buffer(cam);
371 if (vb == NULL) 371 if (vb == NULL)
372 goto done; 372 goto done;
373 /* 373 /*
374 * Figure out which buffer we just completed. 374 * Figure out which buffer we just completed.
375 */ 375 */
376 bufn = (viacam_read_reg(cam, VCR_INTCTRL) & VCR_IC_ACTBUF) >> 3; 376 bufn = (viacam_read_reg(cam, VCR_INTCTRL) & VCR_IC_ACTBUF) >> 3;
377 bufn -= 1; 377 bufn -= 1;
378 if (bufn < 0) 378 if (bufn < 0)
379 bufn = cam->n_cap_bufs - 1; 379 bufn = cam->n_cap_bufs - 1;
380 /* 380 /*
381 * Copy over the data and let any waiters know. 381 * Copy over the data and let any waiters know.
382 */ 382 */
383 vdma = videobuf_to_dma(vb); 383 vdma = videobuf_to_dma(vb);
384 viafb_dma_copy_out_sg(cam->cb_offsets[bufn], vdma->sglist, vdma->sglen); 384 viafb_dma_copy_out_sg(cam->cb_offsets[bufn], vdma->sglist, vdma->sglen);
385 vb->state = VIDEOBUF_DONE; 385 vb->state = VIDEOBUF_DONE;
386 vb->size = cam->user_format.sizeimage; 386 vb->size = cam->user_format.sizeimage;
387 wake_up(&vb->done); 387 wake_up(&vb->done);
388 done: 388 done:
389 return IRQ_HANDLED; 389 return IRQ_HANDLED;
390 } 390 }
391 391
392 392
393 /* 393 /*
394 * These functions must mess around with the general interrupt 394 * These functions must mess around with the general interrupt
395 * control register, which is relevant to much more than just the 395 * control register, which is relevant to much more than just the
396 * camera. Nothing else uses interrupts, though, as of this writing. 396 * camera. Nothing else uses interrupts, though, as of this writing.
397 * Should that situation change, we'll have to improve support at 397 * Should that situation change, we'll have to improve support at
398 * the via-core level. 398 * the via-core level.
399 */ 399 */
400 static void viacam_int_enable(struct via_camera *cam) 400 static void viacam_int_enable(struct via_camera *cam)
401 { 401 {
402 viacam_write_reg(cam, VCR_INTCTRL, 402 viacam_write_reg(cam, VCR_INTCTRL,
403 VCR_IC_INTEN|VCR_IC_EAV|VCR_IC_EVBI|VCR_IC_FFULL); 403 VCR_IC_INTEN|VCR_IC_EAV|VCR_IC_EVBI|VCR_IC_FFULL);
404 viafb_irq_enable(VDE_I_C0AVEN); 404 viafb_irq_enable(VDE_I_C0AVEN);
405 } 405 }
406 406
407 static void viacam_int_disable(struct via_camera *cam) 407 static void viacam_int_disable(struct via_camera *cam)
408 { 408 {
409 viafb_irq_disable(VDE_I_C0AVEN); 409 viafb_irq_disable(VDE_I_C0AVEN);
410 viacam_write_reg(cam, VCR_INTCTRL, 0); 410 viacam_write_reg(cam, VCR_INTCTRL, 0);
411 } 411 }
412 412
413 413
414 414
415 /* --------------------------------------------------------------------------*/ 415 /* --------------------------------------------------------------------------*/
416 /* Controller operations */ 416 /* Controller operations */
417 417
418 /* 418 /*
419 * Set up our capture buffers in framebuffer memory. 419 * Set up our capture buffers in framebuffer memory.
420 */ 420 */
421 static int viacam_ctlr_cbufs(struct via_camera *cam) 421 static int viacam_ctlr_cbufs(struct via_camera *cam)
422 { 422 {
423 int nbuf = cam->viadev->camera_fbmem_size/cam->sensor_format.sizeimage; 423 int nbuf = cam->viadev->camera_fbmem_size/cam->sensor_format.sizeimage;
424 int i; 424 int i;
425 unsigned int offset; 425 unsigned int offset;
426 426
427 /* 427 /*
428 * See how many buffers we can work with. 428 * See how many buffers we can work with.
429 */ 429 */
430 if (nbuf >= 3) { 430 if (nbuf >= 3) {
431 cam->n_cap_bufs = 3; 431 cam->n_cap_bufs = 3;
432 viacam_write_reg_mask(cam, VCR_CAPINTC, VCR_CI_3BUFS, 432 viacam_write_reg_mask(cam, VCR_CAPINTC, VCR_CI_3BUFS,
433 VCR_CI_3BUFS); 433 VCR_CI_3BUFS);
434 } else if (nbuf == 2) { 434 } else if (nbuf == 2) {
435 cam->n_cap_bufs = 2; 435 cam->n_cap_bufs = 2;
436 viacam_write_reg_mask(cam, VCR_CAPINTC, 0, VCR_CI_3BUFS); 436 viacam_write_reg_mask(cam, VCR_CAPINTC, 0, VCR_CI_3BUFS);
437 } else { 437 } else {
438 cam_warn(cam, "Insufficient frame buffer memory\n"); 438 cam_warn(cam, "Insufficient frame buffer memory\n");
439 return -ENOMEM; 439 return -ENOMEM;
440 } 440 }
441 /* 441 /*
442 * Set them up. 442 * Set them up.
443 */ 443 */
444 offset = cam->fb_offset; 444 offset = cam->fb_offset;
445 for (i = 0; i < cam->n_cap_bufs; i++) { 445 for (i = 0; i < cam->n_cap_bufs; i++) {
446 cam->cb_offsets[i] = offset; 446 cam->cb_offsets[i] = offset;
447 cam->cb_addrs[i] = cam->fbmem + offset; 447 cam->cb_addrs[i] = cam->fbmem + offset;
448 viacam_write_reg(cam, VCR_VBUF1 + i*4, offset & VCR_VBUF_MASK); 448 viacam_write_reg(cam, VCR_VBUF1 + i*4, offset & VCR_VBUF_MASK);
449 offset += cam->sensor_format.sizeimage; 449 offset += cam->sensor_format.sizeimage;
450 } 450 }
451 return 0; 451 return 0;
452 } 452 }
453 453
454 /* 454 /*
455 * Set the scaling register for downscaling the image. 455 * Set the scaling register for downscaling the image.
456 * 456 *
457 * This register works like this... Vertical scaling is enabled 457 * This register works like this... Vertical scaling is enabled
458 * by bit 26; if that bit is set, downscaling is controlled by the 458 * by bit 26; if that bit is set, downscaling is controlled by the
459 * value in bits 16:25. Those bits are divided by 1024 to get 459 * value in bits 16:25. Those bits are divided by 1024 to get
460 * the scaling factor; setting just bit 25 thus cuts the height 460 * the scaling factor; setting just bit 25 thus cuts the height
461 * in half. 461 * in half.
462 * 462 *
463 * Horizontal scaling works about the same, but it's enabled by 463 * Horizontal scaling works about the same, but it's enabled by
464 * bit 11, with bits 0:10 giving the numerator of a fraction 464 * bit 11, with bits 0:10 giving the numerator of a fraction
465 * (over 2048) for the scaling value. 465 * (over 2048) for the scaling value.
466 * 466 *
467 * This function is naive in that, if the user departs from 467 * This function is naive in that, if the user departs from
468 * the 3x4 VGA scaling factor, the image will distort. We 468 * the 3x4 VGA scaling factor, the image will distort. We
469 * could work around that if it really seemed important. 469 * could work around that if it really seemed important.
470 */ 470 */
471 static void viacam_set_scale(struct via_camera *cam) 471 static void viacam_set_scale(struct via_camera *cam)
472 { 472 {
473 unsigned int avscale; 473 unsigned int avscale;
474 int sf; 474 int sf;
475 475
476 if (cam->user_format.width == VGA_WIDTH) 476 if (cam->user_format.width == VGA_WIDTH)
477 avscale = 0; 477 avscale = 0;
478 else { 478 else {
479 sf = (cam->user_format.width*2048)/VGA_WIDTH; 479 sf = (cam->user_format.width*2048)/VGA_WIDTH;
480 avscale = VCR_AVS_HEN | sf; 480 avscale = VCR_AVS_HEN | sf;
481 } 481 }
482 if (cam->user_format.height < VGA_HEIGHT) { 482 if (cam->user_format.height < VGA_HEIGHT) {
483 sf = (1024*cam->user_format.height)/VGA_HEIGHT; 483 sf = (1024*cam->user_format.height)/VGA_HEIGHT;
484 avscale |= VCR_AVS_VEN | (sf << 16); 484 avscale |= VCR_AVS_VEN | (sf << 16);
485 } 485 }
486 viacam_write_reg(cam, VCR_AVSCALE, avscale); 486 viacam_write_reg(cam, VCR_AVSCALE, avscale);
487 } 487 }
488 488
489 489
490 /* 490 /*
491 * Configure image-related information into the capture engine. 491 * Configure image-related information into the capture engine.
492 */ 492 */
493 static void viacam_ctlr_image(struct via_camera *cam) 493 static void viacam_ctlr_image(struct via_camera *cam)
494 { 494 {
495 int cicreg; 495 int cicreg;
496 496
497 /* 497 /*
498 * Disable clock before messing with stuff - from the via 498 * Disable clock before messing with stuff - from the via
499 * sample driver. 499 * sample driver.
500 */ 500 */
501 viacam_write_reg(cam, VCR_CAPINTC, ~(VCR_CI_ENABLE|VCR_CI_CLKEN)); 501 viacam_write_reg(cam, VCR_CAPINTC, ~(VCR_CI_ENABLE|VCR_CI_CLKEN));
502 /* 502 /*
503 * Set up the controller for VGA resolution, modulo magic 503 * Set up the controller for VGA resolution, modulo magic
504 * offsets from the via sample driver. 504 * offsets from the via sample driver.
505 */ 505 */
506 viacam_write_reg(cam, VCR_HORRANGE, 0x06200120); 506 viacam_write_reg(cam, VCR_HORRANGE, 0x06200120);
507 viacam_write_reg(cam, VCR_VERTRANGE, 0x01de0000); 507 viacam_write_reg(cam, VCR_VERTRANGE, 0x01de0000);
508 viacam_set_scale(cam); 508 viacam_set_scale(cam);
509 /* 509 /*
510 * Image size info. 510 * Image size info.
511 */ 511 */
512 viacam_write_reg(cam, VCR_MAXDATA, 512 viacam_write_reg(cam, VCR_MAXDATA,
513 (cam->sensor_format.height << 16) | 513 (cam->sensor_format.height << 16) |
514 (cam->sensor_format.bytesperline >> 3)); 514 (cam->sensor_format.bytesperline >> 3));
515 viacam_write_reg(cam, VCR_MAXVBI, 0); 515 viacam_write_reg(cam, VCR_MAXVBI, 0);
516 viacam_write_reg(cam, VCR_VSTRIDE, 516 viacam_write_reg(cam, VCR_VSTRIDE,
517 cam->user_format.bytesperline & VCR_VS_STRIDE); 517 cam->user_format.bytesperline & VCR_VS_STRIDE);
518 /* 518 /*
519 * Set up the capture interface control register, 519 * Set up the capture interface control register,
520 * everything but the "go" bit. 520 * everything but the "go" bit.
521 * 521 *
522 * The FIFO threshold is a bit of a magic number; 8 is what 522 * The FIFO threshold is a bit of a magic number; 8 is what
523 * VIA's sample code uses. 523 * VIA's sample code uses.
524 */ 524 */
525 cicreg = VCR_CI_CLKEN | 525 cicreg = VCR_CI_CLKEN |
526 0x08000000 | /* FIFO threshold */ 526 0x08000000 | /* FIFO threshold */
527 VCR_CI_FLDINV | /* OLPC-specific? */ 527 VCR_CI_FLDINV | /* OLPC-specific? */
528 VCR_CI_VREFINV | /* OLPC-specific? */ 528 VCR_CI_VREFINV | /* OLPC-specific? */
529 VCR_CI_DIBOTH | /* Capture both fields */ 529 VCR_CI_DIBOTH | /* Capture both fields */
530 VCR_CI_CCIR601_8; 530 VCR_CI_CCIR601_8;
531 if (cam->n_cap_bufs == 3) 531 if (cam->n_cap_bufs == 3)
532 cicreg |= VCR_CI_3BUFS; 532 cicreg |= VCR_CI_3BUFS;
533 /* 533 /*
534 * YUV formats need different byte swapping than RGB. 534 * YUV formats need different byte swapping than RGB.
535 */ 535 */
536 if (cam->user_format.pixelformat == V4L2_PIX_FMT_YUYV) 536 if (cam->user_format.pixelformat == V4L2_PIX_FMT_YUYV)
537 cicreg |= VCR_CI_YUYV; 537 cicreg |= VCR_CI_YUYV;
538 else 538 else
539 cicreg |= VCR_CI_UYVY; 539 cicreg |= VCR_CI_UYVY;
540 viacam_write_reg(cam, VCR_CAPINTC, cicreg); 540 viacam_write_reg(cam, VCR_CAPINTC, cicreg);
541 } 541 }
542 542
543 543
544 static int viacam_config_controller(struct via_camera *cam) 544 static int viacam_config_controller(struct via_camera *cam)
545 { 545 {
546 int ret; 546 int ret;
547 unsigned long flags; 547 unsigned long flags;
548 548
549 spin_lock_irqsave(&cam->viadev->reg_lock, flags); 549 spin_lock_irqsave(&cam->viadev->reg_lock, flags);
550 ret = viacam_ctlr_cbufs(cam); 550 ret = viacam_ctlr_cbufs(cam);
551 if (!ret) 551 if (!ret)
552 viacam_ctlr_image(cam); 552 viacam_ctlr_image(cam);
553 spin_unlock_irqrestore(&cam->viadev->reg_lock, flags); 553 spin_unlock_irqrestore(&cam->viadev->reg_lock, flags);
554 clear_bit(CF_CONFIG_NEEDED, &cam->flags); 554 clear_bit(CF_CONFIG_NEEDED, &cam->flags);
555 return ret; 555 return ret;
556 } 556 }
557 557
558 /* 558 /*
559 * Make it start grabbing data. 559 * Make it start grabbing data.
560 */ 560 */
561 static void viacam_start_engine(struct via_camera *cam) 561 static void viacam_start_engine(struct via_camera *cam)
562 { 562 {
563 spin_lock_irq(&cam->viadev->reg_lock); 563 spin_lock_irq(&cam->viadev->reg_lock);
564 cam->next_buf = 0; 564 cam->next_buf = 0;
565 viacam_write_reg_mask(cam, VCR_CAPINTC, VCR_CI_ENABLE, VCR_CI_ENABLE); 565 viacam_write_reg_mask(cam, VCR_CAPINTC, VCR_CI_ENABLE, VCR_CI_ENABLE);
566 viacam_int_enable(cam); 566 viacam_int_enable(cam);
567 (void) viacam_read_reg(cam, VCR_CAPINTC); /* Force post */ 567 (void) viacam_read_reg(cam, VCR_CAPINTC); /* Force post */
568 cam->opstate = S_RUNNING; 568 cam->opstate = S_RUNNING;
569 spin_unlock_irq(&cam->viadev->reg_lock); 569 spin_unlock_irq(&cam->viadev->reg_lock);
570 } 570 }
571 571
572 572
573 static void viacam_stop_engine(struct via_camera *cam) 573 static void viacam_stop_engine(struct via_camera *cam)
574 { 574 {
575 spin_lock_irq(&cam->viadev->reg_lock); 575 spin_lock_irq(&cam->viadev->reg_lock);
576 viacam_int_disable(cam); 576 viacam_int_disable(cam);
577 viacam_write_reg_mask(cam, VCR_CAPINTC, 0, VCR_CI_ENABLE); 577 viacam_write_reg_mask(cam, VCR_CAPINTC, 0, VCR_CI_ENABLE);
578 (void) viacam_read_reg(cam, VCR_CAPINTC); /* Force post */ 578 (void) viacam_read_reg(cam, VCR_CAPINTC); /* Force post */
579 cam->opstate = S_IDLE; 579 cam->opstate = S_IDLE;
580 spin_unlock_irq(&cam->viadev->reg_lock); 580 spin_unlock_irq(&cam->viadev->reg_lock);
581 } 581 }
582 582
583 583
584 /* --------------------------------------------------------------------------*/ 584 /* --------------------------------------------------------------------------*/
585 /* Videobuf callback ops */ 585 /* Videobuf callback ops */
586 586
587 /* 587 /*
588 * buffer_setup. The purpose of this one would appear to be to tell 588 * buffer_setup. The purpose of this one would appear to be to tell
589 * videobuf how big a single image is. It's also evidently up to us 589 * videobuf how big a single image is. It's also evidently up to us
590 * to put some sort of limit on the maximum number of buffers allowed. 590 * to put some sort of limit on the maximum number of buffers allowed.
591 */ 591 */
592 static int viacam_vb_buf_setup(struct videobuf_queue *q, 592 static int viacam_vb_buf_setup(struct videobuf_queue *q,
593 unsigned int *count, unsigned int *size) 593 unsigned int *count, unsigned int *size)
594 { 594 {
595 struct via_camera *cam = q->priv_data; 595 struct via_camera *cam = q->priv_data;
596 596
597 *size = cam->user_format.sizeimage; 597 *size = cam->user_format.sizeimage;
598 if (*count == 0 || *count > 6) /* Arbitrary number */ 598 if (*count == 0 || *count > 6) /* Arbitrary number */
599 *count = 6; 599 *count = 6;
600 return 0; 600 return 0;
601 } 601 }
602 602
603 /* 603 /*
604 * Prepare a buffer. 604 * Prepare a buffer.
605 */ 605 */
606 static int viacam_vb_buf_prepare(struct videobuf_queue *q, 606 static int viacam_vb_buf_prepare(struct videobuf_queue *q,
607 struct videobuf_buffer *vb, enum v4l2_field field) 607 struct videobuf_buffer *vb, enum v4l2_field field)
608 { 608 {
609 struct via_camera *cam = q->priv_data; 609 struct via_camera *cam = q->priv_data;
610 610
611 vb->size = cam->user_format.sizeimage; 611 vb->size = cam->user_format.sizeimage;
612 vb->width = cam->user_format.width; /* bytesperline???? */ 612 vb->width = cam->user_format.width; /* bytesperline???? */
613 vb->height = cam->user_format.height; 613 vb->height = cam->user_format.height;
614 vb->field = field; 614 vb->field = field;
615 if (vb->state == VIDEOBUF_NEEDS_INIT) { 615 if (vb->state == VIDEOBUF_NEEDS_INIT) {
616 int ret = videobuf_iolock(q, vb, NULL); 616 int ret = videobuf_iolock(q, vb, NULL);
617 if (ret) 617 if (ret)
618 return ret; 618 return ret;
619 } 619 }
620 vb->state = VIDEOBUF_PREPARED; 620 vb->state = VIDEOBUF_PREPARED;
621 return 0; 621 return 0;
622 } 622 }
623 623
624 /* 624 /*
625 * We've got a buffer to put data into. 625 * We've got a buffer to put data into.
626 * 626 *
627 * FIXME: check for a running engine and valid buffers? 627 * FIXME: check for a running engine and valid buffers?
628 */ 628 */
629 static void viacam_vb_buf_queue(struct videobuf_queue *q, 629 static void viacam_vb_buf_queue(struct videobuf_queue *q,
630 struct videobuf_buffer *vb) 630 struct videobuf_buffer *vb)
631 { 631 {
632 struct via_camera *cam = q->priv_data; 632 struct via_camera *cam = q->priv_data;
633 633
634 /* 634 /*
635 * Note that videobuf holds the lock when it calls 635 * Note that videobuf holds the lock when it calls
636 * us, so we need not (indeed, cannot) take it here. 636 * us, so we need not (indeed, cannot) take it here.
637 */ 637 */
638 vb->state = VIDEOBUF_QUEUED; 638 vb->state = VIDEOBUF_QUEUED;
639 list_add_tail(&vb->queue, &cam->buffer_queue); 639 list_add_tail(&vb->queue, &cam->buffer_queue);
640 } 640 }
641 641
642 /* 642 /*
643 * Free a buffer. 643 * Free a buffer.
644 */ 644 */
645 static void viacam_vb_buf_release(struct videobuf_queue *q, 645 static void viacam_vb_buf_release(struct videobuf_queue *q,
646 struct videobuf_buffer *vb) 646 struct videobuf_buffer *vb)
647 { 647 {
648 struct via_camera *cam = q->priv_data; 648 struct via_camera *cam = q->priv_data;
649 649
650 videobuf_dma_unmap(&cam->platdev->dev, videobuf_to_dma(vb)); 650 videobuf_dma_unmap(&cam->platdev->dev, videobuf_to_dma(vb));
651 videobuf_dma_free(videobuf_to_dma(vb)); 651 videobuf_dma_free(videobuf_to_dma(vb));
652 vb->state = VIDEOBUF_NEEDS_INIT; 652 vb->state = VIDEOBUF_NEEDS_INIT;
653 } 653 }
654 654
655 static const struct videobuf_queue_ops viacam_vb_ops = { 655 static const struct videobuf_queue_ops viacam_vb_ops = {
656 .buf_setup = viacam_vb_buf_setup, 656 .buf_setup = viacam_vb_buf_setup,
657 .buf_prepare = viacam_vb_buf_prepare, 657 .buf_prepare = viacam_vb_buf_prepare,
658 .buf_queue = viacam_vb_buf_queue, 658 .buf_queue = viacam_vb_buf_queue,
659 .buf_release = viacam_vb_buf_release, 659 .buf_release = viacam_vb_buf_release,
660 }; 660 };
661 661
662 /* --------------------------------------------------------------------------*/ 662 /* --------------------------------------------------------------------------*/
663 /* File operations */ 663 /* File operations */
664 664
665 static int viacam_open(struct file *filp) 665 static int viacam_open(struct file *filp)
666 { 666 {
667 struct via_camera *cam = video_drvdata(filp); 667 struct via_camera *cam = video_drvdata(filp);
668 668
669 filp->private_data = cam; 669 filp->private_data = cam;
670 /* 670 /*
671 * Note the new user. If this is the first one, we'll also 671 * Note the new user. If this is the first one, we'll also
672 * need to power up the sensor. 672 * need to power up the sensor.
673 */ 673 */
674 mutex_lock(&cam->lock); 674 mutex_lock(&cam->lock);
675 if (cam->users == 0) { 675 if (cam->users == 0) {
676 int ret = viafb_request_dma(); 676 int ret = viafb_request_dma();
677 677
678 if (ret) { 678 if (ret) {
679 mutex_unlock(&cam->lock); 679 mutex_unlock(&cam->lock);
680 return ret; 680 return ret;
681 } 681 }
682 via_sensor_power_up(cam); 682 via_sensor_power_up(cam);
683 set_bit(CF_CONFIG_NEEDED, &cam->flags); 683 set_bit(CF_CONFIG_NEEDED, &cam->flags);
684 /* 684 /*
685 * Hook into videobuf. Evidently this cannot fail. 685 * Hook into videobuf. Evidently this cannot fail.
686 */ 686 */
687 videobuf_queue_sg_init(&cam->vb_queue, &viacam_vb_ops, 687 videobuf_queue_sg_init(&cam->vb_queue, &viacam_vb_ops,
688 &cam->platdev->dev, &cam->viadev->reg_lock, 688 &cam->platdev->dev, &cam->viadev->reg_lock,
689 V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE, 689 V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE,
690 sizeof(struct videobuf_buffer), cam, NULL); 690 sizeof(struct videobuf_buffer), cam, NULL);
691 } 691 }
692 (cam->users)++; 692 (cam->users)++;
693 mutex_unlock(&cam->lock); 693 mutex_unlock(&cam->lock);
694 return 0; 694 return 0;
695 } 695 }
696 696
697 static int viacam_release(struct file *filp) 697 static int viacam_release(struct file *filp)
698 { 698 {
699 struct via_camera *cam = video_drvdata(filp); 699 struct via_camera *cam = video_drvdata(filp);
700 700
701 mutex_lock(&cam->lock); 701 mutex_lock(&cam->lock);
702 (cam->users)--; 702 (cam->users)--;
703 /* 703 /*
704 * If the "owner" is closing, shut down any ongoing 704 * If the "owner" is closing, shut down any ongoing
705 * operations. 705 * operations.
706 */ 706 */
707 if (filp == cam->owner) { 707 if (filp == cam->owner) {
708 videobuf_stop(&cam->vb_queue); 708 videobuf_stop(&cam->vb_queue);
709 /* 709 /*
710 * We don't hold the spinlock here, but, if release() 710 * We don't hold the spinlock here, but, if release()
711 * is being called by the owner, nobody else will 711 * is being called by the owner, nobody else will
712 * be changing the state. And an extra stop would 712 * be changing the state. And an extra stop would
713 * not hurt anyway. 713 * not hurt anyway.
714 */ 714 */
715 if (cam->opstate != S_IDLE) 715 if (cam->opstate != S_IDLE)
716 viacam_stop_engine(cam); 716 viacam_stop_engine(cam);
717 cam->owner = NULL; 717 cam->owner = NULL;
718 } 718 }
719 /* 719 /*
720 * Last one out needs to turn out the lights. 720 * Last one out needs to turn out the lights.
721 */ 721 */
722 if (cam->users == 0) { 722 if (cam->users == 0) {
723 videobuf_mmap_free(&cam->vb_queue); 723 videobuf_mmap_free(&cam->vb_queue);
724 via_sensor_power_down(cam); 724 via_sensor_power_down(cam);
725 viafb_release_dma(); 725 viafb_release_dma();
726 } 726 }
727 mutex_unlock(&cam->lock); 727 mutex_unlock(&cam->lock);
728 return 0; 728 return 0;
729 } 729 }
730 730
731 /* 731 /*
732 * Read a frame from the device. 732 * Read a frame from the device.
733 */ 733 */
734 static ssize_t viacam_read(struct file *filp, char __user *buffer, 734 static ssize_t viacam_read(struct file *filp, char __user *buffer,
735 size_t len, loff_t *pos) 735 size_t len, loff_t *pos)
736 { 736 {
737 struct via_camera *cam = video_drvdata(filp); 737 struct via_camera *cam = video_drvdata(filp);
738 int ret; 738 int ret;
739 739
740 mutex_lock(&cam->lock); 740 mutex_lock(&cam->lock);
741 /* 741 /*
742 * Enforce the V4l2 "only one owner gets to read data" rule. 742 * Enforce the V4l2 "only one owner gets to read data" rule.
743 */ 743 */
744 if (cam->owner && cam->owner != filp) { 744 if (cam->owner && cam->owner != filp) {
745 ret = -EBUSY; 745 ret = -EBUSY;
746 goto out_unlock; 746 goto out_unlock;
747 } 747 }
748 cam->owner = filp; 748 cam->owner = filp;
749 /* 749 /*
750 * Do we need to configure the hardware? 750 * Do we need to configure the hardware?
751 */ 751 */
752 if (test_bit(CF_CONFIG_NEEDED, &cam->flags)) { 752 if (test_bit(CF_CONFIG_NEEDED, &cam->flags)) {
753 ret = viacam_configure_sensor(cam); 753 ret = viacam_configure_sensor(cam);
754 if (!ret) 754 if (!ret)
755 ret = viacam_config_controller(cam); 755 ret = viacam_config_controller(cam);
756 if (ret) 756 if (ret)
757 goto out_unlock; 757 goto out_unlock;
758 } 758 }
759 /* 759 /*
760 * Fire up the capture engine, then have videobuf do 760 * Fire up the capture engine, then have videobuf do
761 * the heavy lifting. Someday it would be good to avoid 761 * the heavy lifting. Someday it would be good to avoid
762 * stopping and restarting the engine each time. 762 * stopping and restarting the engine each time.
763 */ 763 */
764 INIT_LIST_HEAD(&cam->buffer_queue); 764 INIT_LIST_HEAD(&cam->buffer_queue);
765 viacam_start_engine(cam); 765 viacam_start_engine(cam);
766 ret = videobuf_read_stream(&cam->vb_queue, buffer, len, pos, 0, 766 ret = videobuf_read_stream(&cam->vb_queue, buffer, len, pos, 0,
767 filp->f_flags & O_NONBLOCK); 767 filp->f_flags & O_NONBLOCK);
768 viacam_stop_engine(cam); 768 viacam_stop_engine(cam);
769 /* videobuf_stop() ?? */ 769 /* videobuf_stop() ?? */
770 770
771 out_unlock: 771 out_unlock:
772 mutex_unlock(&cam->lock); 772 mutex_unlock(&cam->lock);
773 return ret; 773 return ret;
774 } 774 }
775 775
776 776
777 static unsigned int viacam_poll(struct file *filp, struct poll_table_struct *pt) 777 static unsigned int viacam_poll(struct file *filp, struct poll_table_struct *pt)
778 { 778 {
779 struct via_camera *cam = video_drvdata(filp); 779 struct via_camera *cam = video_drvdata(filp);
780 780
781 return videobuf_poll_stream(filp, &cam->vb_queue, pt); 781 return videobuf_poll_stream(filp, &cam->vb_queue, pt);
782 } 782 }
783 783
784 784
785 static int viacam_mmap(struct file *filp, struct vm_area_struct *vma) 785 static int viacam_mmap(struct file *filp, struct vm_area_struct *vma)
786 { 786 {
787 struct via_camera *cam = video_drvdata(filp); 787 struct via_camera *cam = video_drvdata(filp);
788 788
789 return videobuf_mmap_mapper(&cam->vb_queue, vma); 789 return videobuf_mmap_mapper(&cam->vb_queue, vma);
790 } 790 }
791 791
792 792
793 793
794 static const struct v4l2_file_operations viacam_fops = { 794 static const struct v4l2_file_operations viacam_fops = {
795 .owner = THIS_MODULE, 795 .owner = THIS_MODULE,
796 .open = viacam_open, 796 .open = viacam_open,
797 .release = viacam_release, 797 .release = viacam_release,
798 .read = viacam_read, 798 .read = viacam_read,
799 .poll = viacam_poll, 799 .poll = viacam_poll,
800 .mmap = viacam_mmap, 800 .mmap = viacam_mmap,
801 .unlocked_ioctl = video_ioctl2, 801 .unlocked_ioctl = video_ioctl2,
802 }; 802 };
803 803
804 /*----------------------------------------------------------------------------*/ 804 /*----------------------------------------------------------------------------*/
805 /* 805 /*
806 * The long list of v4l2 ioctl ops 806 * The long list of v4l2 ioctl ops
807 */ 807 */
808 808
809 static int viacam_g_chip_ident(struct file *file, void *priv, 809 static int viacam_g_chip_ident(struct file *file, void *priv,
810 struct v4l2_dbg_chip_ident *ident) 810 struct v4l2_dbg_chip_ident *ident)
811 { 811 {
812 struct via_camera *cam = priv; 812 struct via_camera *cam = priv;
813 813
814 ident->ident = V4L2_IDENT_NONE; 814 ident->ident = V4L2_IDENT_NONE;
815 ident->revision = 0; 815 ident->revision = 0;
816 if (v4l2_chip_match_host(&ident->match)) { 816 if (v4l2_chip_match_host(&ident->match)) {
817 ident->ident = V4L2_IDENT_VIA_VX855; 817 ident->ident = V4L2_IDENT_VIA_VX855;
818 return 0; 818 return 0;
819 } 819 }
820 return sensor_call(cam, core, g_chip_ident, ident); 820 return sensor_call(cam, core, g_chip_ident, ident);
821 } 821 }
822 822
823 /* 823 /*
824 * Control ops are passed through to the sensor. 824 * Control ops are passed through to the sensor.
825 */ 825 */
826 static int viacam_queryctrl(struct file *filp, void *priv, 826 static int viacam_queryctrl(struct file *filp, void *priv,
827 struct v4l2_queryctrl *qc) 827 struct v4l2_queryctrl *qc)
828 { 828 {
829 struct via_camera *cam = priv; 829 struct via_camera *cam = priv;
830 int ret; 830 int ret;
831 831
832 mutex_lock(&cam->lock); 832 mutex_lock(&cam->lock);
833 ret = sensor_call(cam, core, queryctrl, qc); 833 ret = sensor_call(cam, core, queryctrl, qc);
834 mutex_unlock(&cam->lock); 834 mutex_unlock(&cam->lock);
835 return ret; 835 return ret;
836 } 836 }
837 837
838 838
839 static int viacam_g_ctrl(struct file *filp, void *priv, 839 static int viacam_g_ctrl(struct file *filp, void *priv,
840 struct v4l2_control *ctrl) 840 struct v4l2_control *ctrl)
841 { 841 {
842 struct via_camera *cam = priv; 842 struct via_camera *cam = priv;
843 int ret; 843 int ret;
844 844
845 mutex_lock(&cam->lock); 845 mutex_lock(&cam->lock);
846 ret = sensor_call(cam, core, g_ctrl, ctrl); 846 ret = sensor_call(cam, core, g_ctrl, ctrl);
847 mutex_unlock(&cam->lock); 847 mutex_unlock(&cam->lock);
848 return ret; 848 return ret;
849 } 849 }
850 850
851 851
852 static int viacam_s_ctrl(struct file *filp, void *priv, 852 static int viacam_s_ctrl(struct file *filp, void *priv,
853 struct v4l2_control *ctrl) 853 struct v4l2_control *ctrl)
854 { 854 {
855 struct via_camera *cam = priv; 855 struct via_camera *cam = priv;
856 int ret; 856 int ret;
857 857
858 mutex_lock(&cam->lock); 858 mutex_lock(&cam->lock);
859 ret = sensor_call(cam, core, s_ctrl, ctrl); 859 ret = sensor_call(cam, core, s_ctrl, ctrl);
860 mutex_unlock(&cam->lock); 860 mutex_unlock(&cam->lock);
861 return ret; 861 return ret;
862 } 862 }
863 863
864 /* 864 /*
865 * Only one input. 865 * Only one input.
866 */ 866 */
867 static int viacam_enum_input(struct file *filp, void *priv, 867 static int viacam_enum_input(struct file *filp, void *priv,
868 struct v4l2_input *input) 868 struct v4l2_input *input)
869 { 869 {
870 if (input->index != 0) 870 if (input->index != 0)
871 return -EINVAL; 871 return -EINVAL;
872 872
873 input->type = V4L2_INPUT_TYPE_CAMERA; 873 input->type = V4L2_INPUT_TYPE_CAMERA;
874 input->std = V4L2_STD_ALL; /* Not sure what should go here */ 874 input->std = V4L2_STD_ALL; /* Not sure what should go here */
875 strcpy(input->name, "Camera"); 875 strcpy(input->name, "Camera");
876 return 0; 876 return 0;
877 } 877 }
878 878
879 static int viacam_g_input(struct file *filp, void *priv, unsigned int *i) 879 static int viacam_g_input(struct file *filp, void *priv, unsigned int *i)
880 { 880 {
881 *i = 0; 881 *i = 0;
882 return 0; 882 return 0;
883 } 883 }
884 884
885 static int viacam_s_input(struct file *filp, void *priv, unsigned int i) 885 static int viacam_s_input(struct file *filp, void *priv, unsigned int i)
886 { 886 {
887 if (i != 0) 887 if (i != 0)
888 return -EINVAL; 888 return -EINVAL;
889 return 0; 889 return 0;
890 } 890 }
891 891
892 static int viacam_s_std(struct file *filp, void *priv, v4l2_std_id *std) 892 static int viacam_s_std(struct file *filp, void *priv, v4l2_std_id *std)
893 { 893 {
894 return 0; 894 return 0;
895 } 895 }
896 896
897 /* 897 /*
898 * Video format stuff. Here is our default format until 898 * Video format stuff. Here is our default format until
899 * user space messes with things. 899 * user space messes with things.
900 */ 900 */
901 static const struct v4l2_pix_format viacam_def_pix_format = { 901 static const struct v4l2_pix_format viacam_def_pix_format = {
902 .width = VGA_WIDTH, 902 .width = VGA_WIDTH,
903 .height = VGA_HEIGHT, 903 .height = VGA_HEIGHT,
904 .pixelformat = V4L2_PIX_FMT_YUYV, 904 .pixelformat = V4L2_PIX_FMT_YUYV,
905 .field = V4L2_FIELD_NONE, 905 .field = V4L2_FIELD_NONE,
906 .bytesperline = VGA_WIDTH * 2, 906 .bytesperline = VGA_WIDTH * 2,
907 .sizeimage = VGA_WIDTH * VGA_HEIGHT * 2, 907 .sizeimage = VGA_WIDTH * VGA_HEIGHT * 2,
908 }; 908 };
909 909
910 static const enum v4l2_mbus_pixelcode via_def_mbus_code = V4L2_MBUS_FMT_YUYV8_2X8; 910 static const enum v4l2_mbus_pixelcode via_def_mbus_code = V4L2_MBUS_FMT_YUYV8_2X8;
911 911
912 static int viacam_enum_fmt_vid_cap(struct file *filp, void *priv, 912 static int viacam_enum_fmt_vid_cap(struct file *filp, void *priv,
913 struct v4l2_fmtdesc *fmt) 913 struct v4l2_fmtdesc *fmt)
914 { 914 {
915 if (fmt->index >= N_VIA_FMTS) 915 if (fmt->index >= N_VIA_FMTS)
916 return -EINVAL; 916 return -EINVAL;
917 strlcpy(fmt->description, via_formats[fmt->index].desc, 917 strlcpy(fmt->description, via_formats[fmt->index].desc,
918 sizeof(fmt->description)); 918 sizeof(fmt->description));
919 fmt->pixelformat = via_formats[fmt->index].pixelformat; 919 fmt->pixelformat = via_formats[fmt->index].pixelformat;
920 return 0; 920 return 0;
921 } 921 }
922 922
923 /* 923 /*
924 * Figure out proper image dimensions, but always force the 924 * Figure out proper image dimensions, but always force the
925 * sensor to VGA. 925 * sensor to VGA.
926 */ 926 */
927 static void viacam_fmt_pre(struct v4l2_pix_format *userfmt, 927 static void viacam_fmt_pre(struct v4l2_pix_format *userfmt,
928 struct v4l2_pix_format *sensorfmt) 928 struct v4l2_pix_format *sensorfmt)
929 { 929 {
930 *sensorfmt = *userfmt; 930 *sensorfmt = *userfmt;
931 if (userfmt->width < QCIF_WIDTH || userfmt->height < QCIF_HEIGHT) { 931 if (userfmt->width < QCIF_WIDTH || userfmt->height < QCIF_HEIGHT) {
932 userfmt->width = QCIF_WIDTH; 932 userfmt->width = QCIF_WIDTH;
933 userfmt->height = QCIF_HEIGHT; 933 userfmt->height = QCIF_HEIGHT;
934 } 934 }
935 if (userfmt->width > VGA_WIDTH || userfmt->height > VGA_HEIGHT) { 935 if (userfmt->width > VGA_WIDTH || userfmt->height > VGA_HEIGHT) {
936 userfmt->width = VGA_WIDTH; 936 userfmt->width = VGA_WIDTH;
937 userfmt->height = VGA_HEIGHT; 937 userfmt->height = VGA_HEIGHT;
938 } 938 }
939 sensorfmt->width = VGA_WIDTH; 939 sensorfmt->width = VGA_WIDTH;
940 sensorfmt->height = VGA_HEIGHT; 940 sensorfmt->height = VGA_HEIGHT;
941 } 941 }
942 942
943 static void viacam_fmt_post(struct v4l2_pix_format *userfmt, 943 static void viacam_fmt_post(struct v4l2_pix_format *userfmt,
944 struct v4l2_pix_format *sensorfmt) 944 struct v4l2_pix_format *sensorfmt)
945 { 945 {
946 struct via_format *f = via_find_format(userfmt->pixelformat); 946 struct via_format *f = via_find_format(userfmt->pixelformat);
947 947
948 sensorfmt->bytesperline = sensorfmt->width * f->bpp; 948 sensorfmt->bytesperline = sensorfmt->width * f->bpp;
949 sensorfmt->sizeimage = sensorfmt->height * sensorfmt->bytesperline; 949 sensorfmt->sizeimage = sensorfmt->height * sensorfmt->bytesperline;
950 userfmt->pixelformat = sensorfmt->pixelformat; 950 userfmt->pixelformat = sensorfmt->pixelformat;
951 userfmt->field = sensorfmt->field; 951 userfmt->field = sensorfmt->field;
952 userfmt->bytesperline = 2 * userfmt->width; 952 userfmt->bytesperline = 2 * userfmt->width;
953 userfmt->sizeimage = userfmt->bytesperline * userfmt->height; 953 userfmt->sizeimage = userfmt->bytesperline * userfmt->height;
954 } 954 }
955 955
956 956
957 /* 957 /*
958 * The real work of figuring out a workable format. 958 * The real work of figuring out a workable format.
959 */ 959 */
960 static int viacam_do_try_fmt(struct via_camera *cam, 960 static int viacam_do_try_fmt(struct via_camera *cam,
961 struct v4l2_pix_format *upix, struct v4l2_pix_format *spix) 961 struct v4l2_pix_format *upix, struct v4l2_pix_format *spix)
962 { 962 {
963 int ret; 963 int ret;
964 struct v4l2_mbus_framefmt mbus_fmt; 964 struct v4l2_mbus_framefmt mbus_fmt;
965 struct via_format *f = via_find_format(upix->pixelformat); 965 struct via_format *f = via_find_format(upix->pixelformat);
966 966
967 upix->pixelformat = f->pixelformat; 967 upix->pixelformat = f->pixelformat;
968 viacam_fmt_pre(upix, spix); 968 viacam_fmt_pre(upix, spix);
969 v4l2_fill_mbus_format(&mbus_fmt, upix, f->mbus_code); 969 v4l2_fill_mbus_format(&mbus_fmt, upix, f->mbus_code);
970 ret = sensor_call(cam, video, try_mbus_fmt, &mbus_fmt); 970 ret = sensor_call(cam, video, try_mbus_fmt, &mbus_fmt);
971 v4l2_fill_pix_format(spix, &mbus_fmt); 971 v4l2_fill_pix_format(spix, &mbus_fmt);
972 viacam_fmt_post(upix, spix); 972 viacam_fmt_post(upix, spix);
973 return ret; 973 return ret;
974 } 974 }
975 975
976 976
977 977
978 static int viacam_try_fmt_vid_cap(struct file *filp, void *priv, 978 static int viacam_try_fmt_vid_cap(struct file *filp, void *priv,
979 struct v4l2_format *fmt) 979 struct v4l2_format *fmt)
980 { 980 {
981 struct via_camera *cam = priv; 981 struct via_camera *cam = priv;
982 struct v4l2_format sfmt; 982 struct v4l2_format sfmt;
983 int ret; 983 int ret;
984 984
985 mutex_lock(&cam->lock); 985 mutex_lock(&cam->lock);
986 ret = viacam_do_try_fmt(cam, &fmt->fmt.pix, &sfmt.fmt.pix); 986 ret = viacam_do_try_fmt(cam, &fmt->fmt.pix, &sfmt.fmt.pix);
987 mutex_unlock(&cam->lock); 987 mutex_unlock(&cam->lock);
988 return ret; 988 return ret;
989 } 989 }
990 990
991 991
992 static int viacam_g_fmt_vid_cap(struct file *filp, void *priv, 992 static int viacam_g_fmt_vid_cap(struct file *filp, void *priv,
993 struct v4l2_format *fmt) 993 struct v4l2_format *fmt)
994 { 994 {
995 struct via_camera *cam = priv; 995 struct via_camera *cam = priv;
996 996
997 mutex_lock(&cam->lock); 997 mutex_lock(&cam->lock);
998 fmt->fmt.pix = cam->user_format; 998 fmt->fmt.pix = cam->user_format;
999 mutex_unlock(&cam->lock); 999 mutex_unlock(&cam->lock);
1000 return 0; 1000 return 0;
1001 } 1001 }
1002 1002
1003 static int viacam_s_fmt_vid_cap(struct file *filp, void *priv, 1003 static int viacam_s_fmt_vid_cap(struct file *filp, void *priv,
1004 struct v4l2_format *fmt) 1004 struct v4l2_format *fmt)
1005 { 1005 {
1006 struct via_camera *cam = priv; 1006 struct via_camera *cam = priv;
1007 int ret; 1007 int ret;
1008 struct v4l2_format sfmt; 1008 struct v4l2_format sfmt;
1009 struct via_format *f = via_find_format(fmt->fmt.pix.pixelformat); 1009 struct via_format *f = via_find_format(fmt->fmt.pix.pixelformat);
1010 1010
1011 /* 1011 /*
1012 * Camera must be idle or we can't mess with the 1012 * Camera must be idle or we can't mess with the
1013 * video setup. 1013 * video setup.
1014 */ 1014 */
1015 mutex_lock(&cam->lock); 1015 mutex_lock(&cam->lock);
1016 if (cam->opstate != S_IDLE) { 1016 if (cam->opstate != S_IDLE) {
1017 ret = -EBUSY; 1017 ret = -EBUSY;
1018 goto out; 1018 goto out;
1019 } 1019 }
1020 /* 1020 /*
1021 * Let the sensor code look over and tweak the 1021 * Let the sensor code look over and tweak the
1022 * requested formatting. 1022 * requested formatting.
1023 */ 1023 */
1024 ret = viacam_do_try_fmt(cam, &fmt->fmt.pix, &sfmt.fmt.pix); 1024 ret = viacam_do_try_fmt(cam, &fmt->fmt.pix, &sfmt.fmt.pix);
1025 if (ret) 1025 if (ret)
1026 goto out; 1026 goto out;
1027 /* 1027 /*
1028 * OK, let's commit to the new format. 1028 * OK, let's commit to the new format.
1029 */ 1029 */
1030 cam->user_format = fmt->fmt.pix; 1030 cam->user_format = fmt->fmt.pix;
1031 cam->sensor_format = sfmt.fmt.pix; 1031 cam->sensor_format = sfmt.fmt.pix;
1032 cam->mbus_code = f->mbus_code; 1032 cam->mbus_code = f->mbus_code;
1033 ret = viacam_configure_sensor(cam); 1033 ret = viacam_configure_sensor(cam);
1034 if (!ret) 1034 if (!ret)
1035 ret = viacam_config_controller(cam); 1035 ret = viacam_config_controller(cam);
1036 out: 1036 out:
1037 mutex_unlock(&cam->lock); 1037 mutex_unlock(&cam->lock);
1038 return ret; 1038 return ret;
1039 } 1039 }
1040 1040
1041 static int viacam_querycap(struct file *filp, void *priv, 1041 static int viacam_querycap(struct file *filp, void *priv,
1042 struct v4l2_capability *cap) 1042 struct v4l2_capability *cap)
1043 { 1043 {
1044 strcpy(cap->driver, "via-camera"); 1044 strcpy(cap->driver, "via-camera");
1045 strcpy(cap->card, "via-camera"); 1045 strcpy(cap->card, "via-camera");
1046 cap->version = 1; 1046 cap->version = 1;
1047 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | 1047 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
1048 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING; 1048 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
1049 return 0; 1049 return 0;
1050 } 1050 }
1051 1051
1052 /* 1052 /*
1053 * Streaming operations - pure videobuf stuff. 1053 * Streaming operations - pure videobuf stuff.
1054 */ 1054 */
1055 static int viacam_reqbufs(struct file *filp, void *priv, 1055 static int viacam_reqbufs(struct file *filp, void *priv,
1056 struct v4l2_requestbuffers *rb) 1056 struct v4l2_requestbuffers *rb)
1057 { 1057 {
1058 struct via_camera *cam = priv; 1058 struct via_camera *cam = priv;
1059 1059
1060 return videobuf_reqbufs(&cam->vb_queue, rb); 1060 return videobuf_reqbufs(&cam->vb_queue, rb);
1061 } 1061 }
1062 1062
1063 static int viacam_querybuf(struct file *filp, void *priv, 1063 static int viacam_querybuf(struct file *filp, void *priv,
1064 struct v4l2_buffer *buf) 1064 struct v4l2_buffer *buf)
1065 { 1065 {
1066 struct via_camera *cam = priv; 1066 struct via_camera *cam = priv;
1067 1067
1068 return videobuf_querybuf(&cam->vb_queue, buf); 1068 return videobuf_querybuf(&cam->vb_queue, buf);
1069 } 1069 }
1070 1070
1071 static int viacam_qbuf(struct file *filp, void *priv, struct v4l2_buffer *buf) 1071 static int viacam_qbuf(struct file *filp, void *priv, struct v4l2_buffer *buf)
1072 { 1072 {
1073 struct via_camera *cam = priv; 1073 struct via_camera *cam = priv;
1074 1074
1075 return videobuf_qbuf(&cam->vb_queue, buf); 1075 return videobuf_qbuf(&cam->vb_queue, buf);
1076 } 1076 }
1077 1077
1078 static int viacam_dqbuf(struct file *filp, void *priv, struct v4l2_buffer *buf) 1078 static int viacam_dqbuf(struct file *filp, void *priv, struct v4l2_buffer *buf)
1079 { 1079 {
1080 struct via_camera *cam = priv; 1080 struct via_camera *cam = priv;
1081 1081
1082 return videobuf_dqbuf(&cam->vb_queue, buf, filp->f_flags & O_NONBLOCK); 1082 return videobuf_dqbuf(&cam->vb_queue, buf, filp->f_flags & O_NONBLOCK);
1083 } 1083 }
1084 1084
1085 static int viacam_streamon(struct file *filp, void *priv, enum v4l2_buf_type t) 1085 static int viacam_streamon(struct file *filp, void *priv, enum v4l2_buf_type t)
1086 { 1086 {
1087 struct via_camera *cam = priv; 1087 struct via_camera *cam = priv;
1088 int ret = 0; 1088 int ret = 0;
1089 1089
1090 if (t != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1090 if (t != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1091 return -EINVAL; 1091 return -EINVAL;
1092 1092
1093 mutex_lock(&cam->lock); 1093 mutex_lock(&cam->lock);
1094 if (cam->opstate != S_IDLE) { 1094 if (cam->opstate != S_IDLE) {
1095 ret = -EBUSY; 1095 ret = -EBUSY;
1096 goto out; 1096 goto out;
1097 } 1097 }
1098 /* 1098 /*
1099 * Enforce the V4l2 "only one owner gets to read data" rule. 1099 * Enforce the V4l2 "only one owner gets to read data" rule.
1100 */ 1100 */
1101 if (cam->owner && cam->owner != filp) { 1101 if (cam->owner && cam->owner != filp) {
1102 ret = -EBUSY; 1102 ret = -EBUSY;
1103 goto out; 1103 goto out;
1104 } 1104 }
1105 cam->owner = filp; 1105 cam->owner = filp;
1106 /* 1106 /*
1107 * Configure things if need be. 1107 * Configure things if need be.
1108 */ 1108 */
1109 if (test_bit(CF_CONFIG_NEEDED, &cam->flags)) { 1109 if (test_bit(CF_CONFIG_NEEDED, &cam->flags)) {
1110 ret = viacam_configure_sensor(cam); 1110 ret = viacam_configure_sensor(cam);
1111 if (ret) 1111 if (ret)
1112 goto out; 1112 goto out;
1113 ret = viacam_config_controller(cam); 1113 ret = viacam_config_controller(cam);
1114 if (ret) 1114 if (ret)
1115 goto out; 1115 goto out;
1116 } 1116 }
1117 /* 1117 /*
1118 * If the CPU goes into C3, the DMA transfer gets corrupted and 1118 * If the CPU goes into C3, the DMA transfer gets corrupted and
1119 * users start filing unsightly bug reports. Put in a "latency" 1119 * users start filing unsightly bug reports. Put in a "latency"
1120 * requirement which will keep the CPU out of the deeper sleep 1120 * requirement which will keep the CPU out of the deeper sleep
1121 * states. 1121 * states.
1122 */ 1122 */
1123 pm_qos_add_request(&cam->qos_request, PM_QOS_CPU_DMA_LATENCY, 50); 1123 pm_qos_add_request(&cam->qos_request, PM_QOS_CPU_DMA_LATENCY, 50);
1124 /* 1124 /*
1125 * Fire things up. 1125 * Fire things up.
1126 */ 1126 */
1127 INIT_LIST_HEAD(&cam->buffer_queue); 1127 INIT_LIST_HEAD(&cam->buffer_queue);
1128 ret = videobuf_streamon(&cam->vb_queue); 1128 ret = videobuf_streamon(&cam->vb_queue);
1129 if (!ret) 1129 if (!ret)
1130 viacam_start_engine(cam); 1130 viacam_start_engine(cam);
1131 out: 1131 out:
1132 mutex_unlock(&cam->lock); 1132 mutex_unlock(&cam->lock);
1133 return ret; 1133 return ret;
1134 } 1134 }
1135 1135
1136 static int viacam_streamoff(struct file *filp, void *priv, enum v4l2_buf_type t) 1136 static int viacam_streamoff(struct file *filp, void *priv, enum v4l2_buf_type t)
1137 { 1137 {
1138 struct via_camera *cam = priv; 1138 struct via_camera *cam = priv;
1139 int ret; 1139 int ret;
1140 1140
1141 if (t != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1141 if (t != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1142 return -EINVAL; 1142 return -EINVAL;
1143 mutex_lock(&cam->lock); 1143 mutex_lock(&cam->lock);
1144 if (cam->opstate != S_RUNNING) { 1144 if (cam->opstate != S_RUNNING) {
1145 ret = -EINVAL; 1145 ret = -EINVAL;
1146 goto out; 1146 goto out;
1147 } 1147 }
1148 pm_qos_remove_request(&cam->qos_request); 1148 pm_qos_remove_request(&cam->qos_request);
1149 viacam_stop_engine(cam); 1149 viacam_stop_engine(cam);
1150 /* 1150 /*
1151 * Videobuf will recycle all of the outstanding buffers, but 1151 * Videobuf will recycle all of the outstanding buffers, but
1152 * we should be sure we don't retain any references to 1152 * we should be sure we don't retain any references to
1153 * any of them. 1153 * any of them.
1154 */ 1154 */
1155 ret = videobuf_streamoff(&cam->vb_queue); 1155 ret = videobuf_streamoff(&cam->vb_queue);
1156 INIT_LIST_HEAD(&cam->buffer_queue); 1156 INIT_LIST_HEAD(&cam->buffer_queue);
1157 out: 1157 out:
1158 mutex_unlock(&cam->lock); 1158 mutex_unlock(&cam->lock);
1159 return ret; 1159 return ret;
1160 } 1160 }
1161 1161
1162 /* G/S_PARM */ 1162 /* G/S_PARM */
1163 1163
1164 static int viacam_g_parm(struct file *filp, void *priv, 1164 static int viacam_g_parm(struct file *filp, void *priv,
1165 struct v4l2_streamparm *parm) 1165 struct v4l2_streamparm *parm)
1166 { 1166 {
1167 struct via_camera *cam = priv; 1167 struct via_camera *cam = priv;
1168 int ret; 1168 int ret;
1169 1169
1170 mutex_lock(&cam->lock); 1170 mutex_lock(&cam->lock);
1171 ret = sensor_call(cam, video, g_parm, parm); 1171 ret = sensor_call(cam, video, g_parm, parm);
1172 mutex_unlock(&cam->lock); 1172 mutex_unlock(&cam->lock);
1173 parm->parm.capture.readbuffers = cam->n_cap_bufs; 1173 parm->parm.capture.readbuffers = cam->n_cap_bufs;
1174 return ret; 1174 return ret;
1175 } 1175 }
1176 1176
1177 static int viacam_s_parm(struct file *filp, void *priv, 1177 static int viacam_s_parm(struct file *filp, void *priv,
1178 struct v4l2_streamparm *parm) 1178 struct v4l2_streamparm *parm)
1179 { 1179 {
1180 struct via_camera *cam = priv; 1180 struct via_camera *cam = priv;
1181 int ret; 1181 int ret;
1182 1182
1183 mutex_lock(&cam->lock); 1183 mutex_lock(&cam->lock);
1184 ret = sensor_call(cam, video, s_parm, parm); 1184 ret = sensor_call(cam, video, s_parm, parm);
1185 mutex_unlock(&cam->lock); 1185 mutex_unlock(&cam->lock);
1186 parm->parm.capture.readbuffers = cam->n_cap_bufs; 1186 parm->parm.capture.readbuffers = cam->n_cap_bufs;
1187 return ret; 1187 return ret;
1188 } 1188 }
1189 1189
1190 static int viacam_enum_framesizes(struct file *filp, void *priv, 1190 static int viacam_enum_framesizes(struct file *filp, void *priv,
1191 struct v4l2_frmsizeenum *sizes) 1191 struct v4l2_frmsizeenum *sizes)
1192 { 1192 {
1193 if (sizes->index != 0) 1193 if (sizes->index != 0)
1194 return -EINVAL; 1194 return -EINVAL;
1195 sizes->type = V4L2_FRMSIZE_TYPE_CONTINUOUS; 1195 sizes->type = V4L2_FRMSIZE_TYPE_CONTINUOUS;
1196 sizes->stepwise.min_width = QCIF_WIDTH; 1196 sizes->stepwise.min_width = QCIF_WIDTH;
1197 sizes->stepwise.min_height = QCIF_HEIGHT; 1197 sizes->stepwise.min_height = QCIF_HEIGHT;
1198 sizes->stepwise.max_width = VGA_WIDTH; 1198 sizes->stepwise.max_width = VGA_WIDTH;
1199 sizes->stepwise.max_height = VGA_HEIGHT; 1199 sizes->stepwise.max_height = VGA_HEIGHT;
1200 sizes->stepwise.step_width = sizes->stepwise.step_height = 1; 1200 sizes->stepwise.step_width = sizes->stepwise.step_height = 1;
1201 return 0; 1201 return 0;
1202 } 1202 }
1203 1203
1204 static int viacam_enum_frameintervals(struct file *filp, void *priv, 1204 static int viacam_enum_frameintervals(struct file *filp, void *priv,
1205 struct v4l2_frmivalenum *interval) 1205 struct v4l2_frmivalenum *interval)
1206 { 1206 {
1207 struct via_camera *cam = priv; 1207 struct via_camera *cam = priv;
1208 int ret; 1208 int ret;
1209 1209
1210 mutex_lock(&cam->lock); 1210 mutex_lock(&cam->lock);
1211 ret = sensor_call(cam, video, enum_frameintervals, interval); 1211 ret = sensor_call(cam, video, enum_frameintervals, interval);
1212 mutex_unlock(&cam->lock); 1212 mutex_unlock(&cam->lock);
1213 return ret; 1213 return ret;
1214 } 1214 }
1215 1215
1216 1216
1217 1217
1218 static const struct v4l2_ioctl_ops viacam_ioctl_ops = { 1218 static const struct v4l2_ioctl_ops viacam_ioctl_ops = {
1219 .vidioc_g_chip_ident = viacam_g_chip_ident, 1219 .vidioc_g_chip_ident = viacam_g_chip_ident,
1220 .vidioc_queryctrl = viacam_queryctrl, 1220 .vidioc_queryctrl = viacam_queryctrl,
1221 .vidioc_g_ctrl = viacam_g_ctrl, 1221 .vidioc_g_ctrl = viacam_g_ctrl,
1222 .vidioc_s_ctrl = viacam_s_ctrl, 1222 .vidioc_s_ctrl = viacam_s_ctrl,
1223 .vidioc_enum_input = viacam_enum_input, 1223 .vidioc_enum_input = viacam_enum_input,
1224 .vidioc_g_input = viacam_g_input, 1224 .vidioc_g_input = viacam_g_input,
1225 .vidioc_s_input = viacam_s_input, 1225 .vidioc_s_input = viacam_s_input,
1226 .vidioc_s_std = viacam_s_std, 1226 .vidioc_s_std = viacam_s_std,
1227 .vidioc_enum_fmt_vid_cap = viacam_enum_fmt_vid_cap, 1227 .vidioc_enum_fmt_vid_cap = viacam_enum_fmt_vid_cap,
1228 .vidioc_try_fmt_vid_cap = viacam_try_fmt_vid_cap, 1228 .vidioc_try_fmt_vid_cap = viacam_try_fmt_vid_cap,
1229 .vidioc_g_fmt_vid_cap = viacam_g_fmt_vid_cap, 1229 .vidioc_g_fmt_vid_cap = viacam_g_fmt_vid_cap,
1230 .vidioc_s_fmt_vid_cap = viacam_s_fmt_vid_cap, 1230 .vidioc_s_fmt_vid_cap = viacam_s_fmt_vid_cap,
1231 .vidioc_querycap = viacam_querycap, 1231 .vidioc_querycap = viacam_querycap,
1232 .vidioc_reqbufs = viacam_reqbufs, 1232 .vidioc_reqbufs = viacam_reqbufs,
1233 .vidioc_querybuf = viacam_querybuf, 1233 .vidioc_querybuf = viacam_querybuf,
1234 .vidioc_qbuf = viacam_qbuf, 1234 .vidioc_qbuf = viacam_qbuf,
1235 .vidioc_dqbuf = viacam_dqbuf, 1235 .vidioc_dqbuf = viacam_dqbuf,
1236 .vidioc_streamon = viacam_streamon, 1236 .vidioc_streamon = viacam_streamon,
1237 .vidioc_streamoff = viacam_streamoff, 1237 .vidioc_streamoff = viacam_streamoff,
1238 .vidioc_g_parm = viacam_g_parm, 1238 .vidioc_g_parm = viacam_g_parm,
1239 .vidioc_s_parm = viacam_s_parm, 1239 .vidioc_s_parm = viacam_s_parm,
1240 .vidioc_enum_framesizes = viacam_enum_framesizes, 1240 .vidioc_enum_framesizes = viacam_enum_framesizes,
1241 .vidioc_enum_frameintervals = viacam_enum_frameintervals, 1241 .vidioc_enum_frameintervals = viacam_enum_frameintervals,
1242 }; 1242 };
1243 1243
1244 /*----------------------------------------------------------------------------*/ 1244 /*----------------------------------------------------------------------------*/
1245 1245
1246 /* 1246 /*
1247 * Power management. 1247 * Power management.
1248 */ 1248 */
1249 #ifdef CONFIG_PM 1249 #ifdef CONFIG_PM
1250 1250
1251 static int viacam_suspend(void *priv) 1251 static int viacam_suspend(void *priv)
1252 { 1252 {
1253 struct via_camera *cam = priv; 1253 struct via_camera *cam = priv;
1254 enum viacam_opstate state = cam->opstate; 1254 enum viacam_opstate state = cam->opstate;
1255 1255
1256 if (cam->opstate != S_IDLE) { 1256 if (cam->opstate != S_IDLE) {
1257 viacam_stop_engine(cam); 1257 viacam_stop_engine(cam);
1258 cam->opstate = state; /* So resume restarts */ 1258 cam->opstate = state; /* So resume restarts */
1259 } 1259 }
1260 1260
1261 return 0; 1261 return 0;
1262 } 1262 }
1263 1263
1264 static int viacam_resume(void *priv) 1264 static int viacam_resume(void *priv)
1265 { 1265 {
1266 struct via_camera *cam = priv; 1266 struct via_camera *cam = priv;
1267 int ret = 0; 1267 int ret = 0;
1268 1268
1269 /* 1269 /*
1270 * Get back to a reasonable operating state. 1270 * Get back to a reasonable operating state.
1271 */ 1271 */
1272 via_write_reg_mask(VIASR, 0x78, 0, 0x80); 1272 via_write_reg_mask(VIASR, 0x78, 0, 0x80);
1273 via_write_reg_mask(VIASR, 0x1e, 0xc0, 0xc0); 1273 via_write_reg_mask(VIASR, 0x1e, 0xc0, 0xc0);
1274 viacam_int_disable(cam); 1274 viacam_int_disable(cam);
1275 set_bit(CF_CONFIG_NEEDED, &cam->flags); 1275 set_bit(CF_CONFIG_NEEDED, &cam->flags);
1276 /* 1276 /*
1277 * Make sure the sensor's power state is correct 1277 * Make sure the sensor's power state is correct
1278 */ 1278 */
1279 if (cam->users > 0) 1279 if (cam->users > 0)
1280 via_sensor_power_up(cam); 1280 via_sensor_power_up(cam);
1281 else 1281 else
1282 via_sensor_power_down(cam); 1282 via_sensor_power_down(cam);
1283 /* 1283 /*
1284 * If it was operating, try to restart it. 1284 * If it was operating, try to restart it.
1285 */ 1285 */
1286 if (cam->opstate != S_IDLE) { 1286 if (cam->opstate != S_IDLE) {
1287 mutex_lock(&cam->lock); 1287 mutex_lock(&cam->lock);
1288 ret = viacam_configure_sensor(cam); 1288 ret = viacam_configure_sensor(cam);
1289 if (!ret) 1289 if (!ret)
1290 ret = viacam_config_controller(cam); 1290 ret = viacam_config_controller(cam);
1291 mutex_unlock(&cam->lock); 1291 mutex_unlock(&cam->lock);
1292 if (!ret) 1292 if (!ret)
1293 viacam_start_engine(cam); 1293 viacam_start_engine(cam);
1294 } 1294 }
1295 1295
1296 return ret; 1296 return ret;
1297 } 1297 }
1298 1298
1299 static struct viafb_pm_hooks viacam_pm_hooks = { 1299 static struct viafb_pm_hooks viacam_pm_hooks = {
1300 .suspend = viacam_suspend, 1300 .suspend = viacam_suspend,
1301 .resume = viacam_resume 1301 .resume = viacam_resume
1302 }; 1302 };
1303 1303
1304 #endif /* CONFIG_PM */ 1304 #endif /* CONFIG_PM */
1305 1305
1306 /* 1306 /*
1307 * Setup stuff. 1307 * Setup stuff.
1308 */ 1308 */
1309 1309
1310 static struct video_device viacam_v4l_template = { 1310 static struct video_device viacam_v4l_template = {
1311 .name = "via-camera", 1311 .name = "via-camera",
1312 .minor = -1, 1312 .minor = -1,
1313 .tvnorms = V4L2_STD_NTSC_M, 1313 .tvnorms = V4L2_STD_NTSC_M,
1314 .current_norm = V4L2_STD_NTSC_M, 1314 .current_norm = V4L2_STD_NTSC_M,
1315 .fops = &viacam_fops, 1315 .fops = &viacam_fops,
1316 .ioctl_ops = &viacam_ioctl_ops, 1316 .ioctl_ops = &viacam_ioctl_ops,
1317 .release = video_device_release_empty, /* Check this */ 1317 .release = video_device_release_empty, /* Check this */
1318 }; 1318 };
1319 1319
1320 /* 1320 /*
1321 * The OLPC folks put the serial port on the same pin as 1321 * The OLPC folks put the serial port on the same pin as
1322 * the camera. They also get grumpy if we break the 1322 * the camera. They also get grumpy if we break the
1323 * serial port and keep them from using it. So we have 1323 * serial port and keep them from using it. So we have
1324 * to check the serial enable bit and not step on it. 1324 * to check the serial enable bit and not step on it.
1325 */ 1325 */
1326 #define VIACAM_SERIAL_DEVFN 0x88 1326 #define VIACAM_SERIAL_DEVFN 0x88
1327 #define VIACAM_SERIAL_CREG 0x46 1327 #define VIACAM_SERIAL_CREG 0x46
1328 #define VIACAM_SERIAL_BIT 0x40 1328 #define VIACAM_SERIAL_BIT 0x40
1329 1329
1330 static __devinit bool viacam_serial_is_enabled(void) 1330 static __devinit bool viacam_serial_is_enabled(void)
1331 { 1331 {
1332 struct pci_bus *pbus = pci_find_bus(0, 0); 1332 struct pci_bus *pbus = pci_find_bus(0, 0);
1333 u8 cbyte; 1333 u8 cbyte;
1334 1334
1335 pci_bus_read_config_byte(pbus, VIACAM_SERIAL_DEVFN, 1335 pci_bus_read_config_byte(pbus, VIACAM_SERIAL_DEVFN,
1336 VIACAM_SERIAL_CREG, &cbyte); 1336 VIACAM_SERIAL_CREG, &cbyte);
1337 if ((cbyte & VIACAM_SERIAL_BIT) == 0) 1337 if ((cbyte & VIACAM_SERIAL_BIT) == 0)
1338 return false; /* Not enabled */ 1338 return false; /* Not enabled */
1339 if (override_serial == 0) { 1339 if (override_serial == 0) {
1340 printk(KERN_NOTICE "Via camera: serial port is enabled, " \ 1340 printk(KERN_NOTICE "Via camera: serial port is enabled, " \
1341 "refusing to load.\n"); 1341 "refusing to load.\n");
1342 printk(KERN_NOTICE "Specify override_serial=1 to force " \ 1342 printk(KERN_NOTICE "Specify override_serial=1 to force " \
1343 "module loading.\n"); 1343 "module loading.\n");
1344 return true; 1344 return true;
1345 } 1345 }
1346 printk(KERN_NOTICE "Via camera: overriding serial port\n"); 1346 printk(KERN_NOTICE "Via camera: overriding serial port\n");
1347 pci_bus_write_config_byte(pbus, VIACAM_SERIAL_DEVFN, 1347 pci_bus_write_config_byte(pbus, VIACAM_SERIAL_DEVFN,
1348 VIACAM_SERIAL_CREG, cbyte & ~VIACAM_SERIAL_BIT); 1348 VIACAM_SERIAL_CREG, cbyte & ~VIACAM_SERIAL_BIT);
1349 return false; 1349 return false;
1350 } 1350 }
1351 1351
1352 static __devinit int viacam_probe(struct platform_device *pdev) 1352 static __devinit int viacam_probe(struct platform_device *pdev)
1353 { 1353 {
1354 int ret; 1354 int ret;
1355 struct i2c_adapter *sensor_adapter; 1355 struct i2c_adapter *sensor_adapter;
1356 struct viafb_dev *viadev = pdev->dev.platform_data; 1356 struct viafb_dev *viadev = pdev->dev.platform_data;
1357 1357
1358 /* 1358 /*
1359 * Note that there are actually two capture channels on 1359 * Note that there are actually two capture channels on
1360 * the device. We only deal with one for now. That 1360 * the device. We only deal with one for now. That
1361 * is encoded here; nothing else assumes it's dealing with 1361 * is encoded here; nothing else assumes it's dealing with
1362 * a unique capture device. 1362 * a unique capture device.
1363 */ 1363 */
1364 struct via_camera *cam; 1364 struct via_camera *cam;
1365 1365
1366 /* 1366 /*
1367 * Ensure that frame buffer memory has been set aside for 1367 * Ensure that frame buffer memory has been set aside for
1368 * this purpose. As an arbitrary limit, refuse to work 1368 * this purpose. As an arbitrary limit, refuse to work
1369 * with less than two frames of VGA 16-bit data. 1369 * with less than two frames of VGA 16-bit data.
1370 * 1370 *
1371 * If we ever support the second port, we'll need to set 1371 * If we ever support the second port, we'll need to set
1372 * aside more memory. 1372 * aside more memory.
1373 */ 1373 */
1374 if (viadev->camera_fbmem_size < (VGA_HEIGHT*VGA_WIDTH*4)) { 1374 if (viadev->camera_fbmem_size < (VGA_HEIGHT*VGA_WIDTH*4)) {
1375 printk(KERN_ERR "viacam: insufficient FB memory reserved\n"); 1375 printk(KERN_ERR "viacam: insufficient FB memory reserved\n");
1376 return -ENOMEM; 1376 return -ENOMEM;
1377 } 1377 }
1378 if (viadev->engine_mmio == NULL) { 1378 if (viadev->engine_mmio == NULL) {
1379 printk(KERN_ERR "viacam: No I/O memory, so no pictures\n"); 1379 printk(KERN_ERR "viacam: No I/O memory, so no pictures\n");
1380 return -ENOMEM; 1380 return -ENOMEM;
1381 } 1381 }
1382 1382
1383 if (machine_is_olpc() && viacam_serial_is_enabled()) 1383 if (machine_is_olpc() && viacam_serial_is_enabled())
1384 return -EBUSY; 1384 return -EBUSY;
1385 1385
1386 /* 1386 /*
1387 * Basic structure initialization. 1387 * Basic structure initialization.
1388 */ 1388 */
1389 cam = kzalloc (sizeof(struct via_camera), GFP_KERNEL); 1389 cam = kzalloc (sizeof(struct via_camera), GFP_KERNEL);
1390 if (cam == NULL) 1390 if (cam == NULL)
1391 return -ENOMEM; 1391 return -ENOMEM;
1392 via_cam_info = cam; 1392 via_cam_info = cam;
1393 cam->platdev = pdev; 1393 cam->platdev = pdev;
1394 cam->viadev = viadev; 1394 cam->viadev = viadev;
1395 cam->users = 0; 1395 cam->users = 0;
1396 cam->owner = NULL; 1396 cam->owner = NULL;
1397 cam->opstate = S_IDLE; 1397 cam->opstate = S_IDLE;
1398 cam->user_format = cam->sensor_format = viacam_def_pix_format; 1398 cam->user_format = cam->sensor_format = viacam_def_pix_format;
1399 mutex_init(&cam->lock); 1399 mutex_init(&cam->lock);
1400 INIT_LIST_HEAD(&cam->buffer_queue); 1400 INIT_LIST_HEAD(&cam->buffer_queue);
1401 cam->mmio = viadev->engine_mmio; 1401 cam->mmio = viadev->engine_mmio;
1402 cam->fbmem = viadev->fbmem; 1402 cam->fbmem = viadev->fbmem;
1403 cam->fb_offset = viadev->camera_fbmem_offset; 1403 cam->fb_offset = viadev->camera_fbmem_offset;
1404 cam->flags = 1 << CF_CONFIG_NEEDED; 1404 cam->flags = 1 << CF_CONFIG_NEEDED;
1405 cam->mbus_code = via_def_mbus_code; 1405 cam->mbus_code = via_def_mbus_code;
1406 /* 1406 /*
1407 * Tell V4L that we exist. 1407 * Tell V4L that we exist.
1408 */ 1408 */
1409 ret = v4l2_device_register(&pdev->dev, &cam->v4l2_dev); 1409 ret = v4l2_device_register(&pdev->dev, &cam->v4l2_dev);
1410 if (ret) { 1410 if (ret) {
1411 dev_err(&pdev->dev, "Unable to register v4l2 device\n"); 1411 dev_err(&pdev->dev, "Unable to register v4l2 device\n");
1412 return ret; 1412 return ret;
1413 } 1413 }
1414 /* 1414 /*
1415 * Convince the system that we can do DMA. 1415 * Convince the system that we can do DMA.
1416 */ 1416 */
1417 pdev->dev.dma_mask = &viadev->pdev->dma_mask; 1417 pdev->dev.dma_mask = &viadev->pdev->dma_mask;
1418 dma_set_mask(&pdev->dev, 0xffffffff); 1418 dma_set_mask(&pdev->dev, 0xffffffff);
1419 /* 1419 /*
1420 * Fire up the capture port. The write to 0x78 looks purely 1420 * Fire up the capture port. The write to 0x78 looks purely
1421 * OLPCish; any system will need to tweak 0x1e. 1421 * OLPCish; any system will need to tweak 0x1e.
1422 */ 1422 */
1423 via_write_reg_mask(VIASR, 0x78, 0, 0x80); 1423 via_write_reg_mask(VIASR, 0x78, 0, 0x80);
1424 via_write_reg_mask(VIASR, 0x1e, 0xc0, 0xc0); 1424 via_write_reg_mask(VIASR, 0x1e, 0xc0, 0xc0);
1425 /* 1425 /*
1426 * Get the sensor powered up. 1426 * Get the sensor powered up.
1427 */ 1427 */
1428 ret = via_sensor_power_setup(cam); 1428 ret = via_sensor_power_setup(cam);
1429 if (ret) 1429 if (ret)
1430 goto out_unregister; 1430 goto out_unregister;
1431 via_sensor_power_up(cam); 1431 via_sensor_power_up(cam);
1432 1432
1433 /* 1433 /*
1434 * See if we can't find it on the bus. The VIA_PORT_31 assumption 1434 * See if we can't find it on the bus. The VIA_PORT_31 assumption
1435 * is OLPC-specific. 0x42 assumption is ov7670-specific. 1435 * is OLPC-specific. 0x42 assumption is ov7670-specific.
1436 */ 1436 */
1437 sensor_adapter = viafb_find_i2c_adapter(VIA_PORT_31); 1437 sensor_adapter = viafb_find_i2c_adapter(VIA_PORT_31);
1438 cam->sensor = v4l2_i2c_new_subdev(&cam->v4l2_dev, sensor_adapter, 1438 cam->sensor = v4l2_i2c_new_subdev(&cam->v4l2_dev, sensor_adapter,
1439 "ov7670", 0x42 >> 1, NULL); 1439 "ov7670", 0x42 >> 1, NULL);
1440 if (cam->sensor == NULL) { 1440 if (cam->sensor == NULL) {
1441 dev_err(&pdev->dev, "Unable to find the sensor!\n"); 1441 dev_err(&pdev->dev, "Unable to find the sensor!\n");
1442 ret = -ENODEV; 1442 ret = -ENODEV;
1443 goto out_power_down; 1443 goto out_power_down;
1444 } 1444 }
1445 /* 1445 /*
1446 * Get the IRQ. 1446 * Get the IRQ.
1447 */ 1447 */
1448 viacam_int_disable(cam); 1448 viacam_int_disable(cam);
1449 ret = request_threaded_irq(viadev->pdev->irq, viacam_quick_irq, 1449 ret = request_threaded_irq(viadev->pdev->irq, viacam_quick_irq,
1450 viacam_irq, IRQF_SHARED, "via-camera", cam); 1450 viacam_irq, IRQF_SHARED, "via-camera", cam);
1451 if (ret) 1451 if (ret)
1452 goto out_power_down; 1452 goto out_power_down;
1453 /* 1453 /*
1454 * Tell V4l2 that we exist. 1454 * Tell V4l2 that we exist.
1455 */ 1455 */
1456 cam->vdev = viacam_v4l_template; 1456 cam->vdev = viacam_v4l_template;
1457 cam->vdev.v4l2_dev = &cam->v4l2_dev; 1457 cam->vdev.v4l2_dev = &cam->v4l2_dev;
1458 ret = video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1); 1458 ret = video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1);
1459 if (ret) 1459 if (ret)
1460 goto out_irq; 1460 goto out_irq;
1461 video_set_drvdata(&cam->vdev, cam); 1461 video_set_drvdata(&cam->vdev, cam);
1462 1462
1463 #ifdef CONFIG_PM 1463 #ifdef CONFIG_PM
1464 /* 1464 /*
1465 * Hook into PM events 1465 * Hook into PM events
1466 */ 1466 */
1467 viacam_pm_hooks.private = cam; 1467 viacam_pm_hooks.private = cam;
1468 viafb_pm_register(&viacam_pm_hooks); 1468 viafb_pm_register(&viacam_pm_hooks);
1469 #endif 1469 #endif
1470 1470
1471 /* Power the sensor down until somebody opens the device */ 1471 /* Power the sensor down until somebody opens the device */
1472 via_sensor_power_down(cam); 1472 via_sensor_power_down(cam);
1473 return 0; 1473 return 0;
1474 1474
1475 out_irq: 1475 out_irq:
1476 free_irq(viadev->pdev->irq, cam); 1476 free_irq(viadev->pdev->irq, cam);
1477 out_power_down: 1477 out_power_down:
1478 via_sensor_power_release(cam); 1478 via_sensor_power_release(cam);
1479 out_unregister: 1479 out_unregister:
1480 v4l2_device_unregister(&cam->v4l2_dev); 1480 v4l2_device_unregister(&cam->v4l2_dev);
1481 return ret; 1481 return ret;
1482 } 1482 }
1483 1483
1484 static __devexit int viacam_remove(struct platform_device *pdev) 1484 static __devexit int viacam_remove(struct platform_device *pdev)
1485 { 1485 {
1486 struct via_camera *cam = via_cam_info; 1486 struct via_camera *cam = via_cam_info;
1487 struct viafb_dev *viadev = pdev->dev.platform_data; 1487 struct viafb_dev *viadev = pdev->dev.platform_data;
1488 1488
1489 video_unregister_device(&cam->vdev); 1489 video_unregister_device(&cam->vdev);
1490 v4l2_device_unregister(&cam->v4l2_dev); 1490 v4l2_device_unregister(&cam->v4l2_dev);
1491 free_irq(viadev->pdev->irq, cam); 1491 free_irq(viadev->pdev->irq, cam);
1492 via_sensor_power_release(cam); 1492 via_sensor_power_release(cam);
1493 via_cam_info = NULL; 1493 via_cam_info = NULL;
1494 return 0; 1494 return 0;
1495 } 1495 }
1496 1496
1497 static struct platform_driver viacam_driver = { 1497 static struct platform_driver viacam_driver = {
1498 .driver = { 1498 .driver = {
1499 .name = "viafb-camera", 1499 .name = "viafb-camera",
1500 }, 1500 },
1501 .probe = viacam_probe, 1501 .probe = viacam_probe,
1502 .remove = viacam_remove, 1502 .remove = viacam_remove,
1503 }; 1503 };
1504 1504
1505 static int viacam_init(void) 1505 static int viacam_init(void)
1506 { 1506 {
1507 return platform_driver_register(&viacam_driver); 1507 return platform_driver_register(&viacam_driver);
1508 } 1508 }
1509 module_init(viacam_init); 1509 module_init(viacam_init);
1510 1510
1511 static void viacam_exit(void) 1511 static void viacam_exit(void)
1512 { 1512 {
1513 platform_driver_unregister(&viacam_driver); 1513 platform_driver_unregister(&viacam_driver);
1514 } 1514 }
1515 module_exit(viacam_exit); 1515 module_exit(viacam_exit);
1516 1516
drivers/net/wireless/ipw2x00/ipw2100.c
Diff comments   View file @ cc74998
1 /****************************************************************************** 1 /******************************************************************************
2 2
3 Copyright(c) 2003 - 2006 Intel Corporation. All rights reserved. 3 Copyright(c) 2003 - 2006 Intel Corporation. All rights reserved.
4 4
5 This program is free software; you can redistribute it and/or modify it 5 This program is free software; you can redistribute it and/or modify it
6 under the terms of version 2 of the GNU General Public License as 6 under the terms of version 2 of the GNU General Public License as
7 published by the Free Software Foundation. 7 published by the Free Software Foundation.
8 8
9 This program is distributed in the hope that it will be useful, but WITHOUT 9 This program is distributed in the hope that it will be useful, but WITHOUT
10 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 10 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 11 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 more details. 12 more details.
13 13
14 You should have received a copy of the GNU General Public License along with 14 You should have received a copy of the GNU General Public License along with
15 this program; if not, write to the Free Software Foundation, Inc., 59 15 this program; if not, write to the Free Software Foundation, Inc., 59
16 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 16 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17 17
18 The full GNU General Public License is included in this distribution in the 18 The full GNU General Public License is included in this distribution in the
19 file called LICENSE. 19 file called LICENSE.
20 20
21 Contact Information: 21 Contact Information:
22 Intel Linux Wireless <ilw@linux.intel.com> 22 Intel Linux Wireless <ilw@linux.intel.com>
23 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 23 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
24 24
25 Portions of this file are based on the sample_* files provided by Wireless 25 Portions of this file are based on the sample_* files provided by Wireless
26 Extensions 0.26 package and copyright (c) 1997-2003 Jean Tourrilhes 26 Extensions 0.26 package and copyright (c) 1997-2003 Jean Tourrilhes
27 <jt@hpl.hp.com> 27 <jt@hpl.hp.com>
28 28
29 Portions of this file are based on the Host AP project, 29 Portions of this file are based on the Host AP project,
30 Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen 30 Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen
31 <j@w1.fi> 31 <j@w1.fi>
32 Copyright (c) 2002-2003, Jouni Malinen <j@w1.fi> 32 Copyright (c) 2002-2003, Jouni Malinen <j@w1.fi>
33 33
34 Portions of ipw2100_mod_firmware_load, ipw2100_do_mod_firmware_load, and 34 Portions of ipw2100_mod_firmware_load, ipw2100_do_mod_firmware_load, and
35 ipw2100_fw_load are loosely based on drivers/sound/sound_firmware.c 35 ipw2100_fw_load are loosely based on drivers/sound/sound_firmware.c
36 available in the 2.4.25 kernel sources, and are copyright (c) Alan Cox 36 available in the 2.4.25 kernel sources, and are copyright (c) Alan Cox
37 37
38 ******************************************************************************/ 38 ******************************************************************************/
39 /* 39 /*
40 40
41 Initial driver on which this is based was developed by Janusz Gorycki, 41 Initial driver on which this is based was developed by Janusz Gorycki,
42 Maciej Urbaniak, and Maciej Sosnowski. 42 Maciej Urbaniak, and Maciej Sosnowski.
43 43
44 Promiscuous mode support added by Jacek Wysoczynski and Maciej Urbaniak. 44 Promiscuous mode support added by Jacek Wysoczynski and Maciej Urbaniak.
45 45
46 Theory of Operation 46 Theory of Operation
47 47
48 Tx - Commands and Data 48 Tx - Commands and Data
49 49
50 Firmware and host share a circular queue of Transmit Buffer Descriptors (TBDs) 50 Firmware and host share a circular queue of Transmit Buffer Descriptors (TBDs)
51 Each TBD contains a pointer to the physical (dma_addr_t) address of data being 51 Each TBD contains a pointer to the physical (dma_addr_t) address of data being
52 sent to the firmware as well as the length of the data. 52 sent to the firmware as well as the length of the data.
53 53
54 The host writes to the TBD queue at the WRITE index. The WRITE index points 54 The host writes to the TBD queue at the WRITE index. The WRITE index points
55 to the _next_ packet to be written and is advanced when after the TBD has been 55 to the _next_ packet to be written and is advanced when after the TBD has been
56 filled. 56 filled.
57 57
58 The firmware pulls from the TBD queue at the READ index. The READ index points 58 The firmware pulls from the TBD queue at the READ index. The READ index points
59 to the currently being read entry, and is advanced once the firmware is 59 to the currently being read entry, and is advanced once the firmware is
60 done with a packet. 60 done with a packet.
61 61
62 When data is sent to the firmware, the first TBD is used to indicate to the 62 When data is sent to the firmware, the first TBD is used to indicate to the
63 firmware if a Command or Data is being sent. If it is Command, all of the 63 firmware if a Command or Data is being sent. If it is Command, all of the
64 command information is contained within the physical address referred to by the 64 command information is contained within the physical address referred to by the
65 TBD. If it is Data, the first TBD indicates the type of data packet, number 65 TBD. If it is Data, the first TBD indicates the type of data packet, number
66 of fragments, etc. The next TBD then refers to the actual packet location. 66 of fragments, etc. The next TBD then refers to the actual packet location.
67 67
68 The Tx flow cycle is as follows: 68 The Tx flow cycle is as follows:
69 69
70 1) ipw2100_tx() is called by kernel with SKB to transmit 70 1) ipw2100_tx() is called by kernel with SKB to transmit
71 2) Packet is move from the tx_free_list and appended to the transmit pending 71 2) Packet is move from the tx_free_list and appended to the transmit pending
72 list (tx_pend_list) 72 list (tx_pend_list)
73 3) work is scheduled to move pending packets into the shared circular queue. 73 3) work is scheduled to move pending packets into the shared circular queue.
74 4) when placing packet in the circular queue, the incoming SKB is DMA mapped 74 4) when placing packet in the circular queue, the incoming SKB is DMA mapped
75 to a physical address. That address is entered into a TBD. Two TBDs are 75 to a physical address. That address is entered into a TBD. Two TBDs are
76 filled out. The first indicating a data packet, the second referring to the 76 filled out. The first indicating a data packet, the second referring to the
77 actual payload data. 77 actual payload data.
78 5) the packet is removed from tx_pend_list and placed on the end of the 78 5) the packet is removed from tx_pend_list and placed on the end of the
79 firmware pending list (fw_pend_list) 79 firmware pending list (fw_pend_list)
80 6) firmware is notified that the WRITE index has 80 6) firmware is notified that the WRITE index has
81 7) Once the firmware has processed the TBD, INTA is triggered. 81 7) Once the firmware has processed the TBD, INTA is triggered.
82 8) For each Tx interrupt received from the firmware, the READ index is checked 82 8) For each Tx interrupt received from the firmware, the READ index is checked
83 to see which TBDs are done being processed. 83 to see which TBDs are done being processed.
84 9) For each TBD that has been processed, the ISR pulls the oldest packet 84 9) For each TBD that has been processed, the ISR pulls the oldest packet
85 from the fw_pend_list. 85 from the fw_pend_list.
86 10)The packet structure contained in the fw_pend_list is then used 86 10)The packet structure contained in the fw_pend_list is then used
87 to unmap the DMA address and to free the SKB originally passed to the driver 87 to unmap the DMA address and to free the SKB originally passed to the driver
88 from the kernel. 88 from the kernel.
89 11)The packet structure is placed onto the tx_free_list 89 11)The packet structure is placed onto the tx_free_list
90 90
91 The above steps are the same for commands, only the msg_free_list/msg_pend_list 91 The above steps are the same for commands, only the msg_free_list/msg_pend_list
92 are used instead of tx_free_list/tx_pend_list 92 are used instead of tx_free_list/tx_pend_list
93 93
94 ... 94 ...
95 95
96 Critical Sections / Locking : 96 Critical Sections / Locking :
97 97
98 There are two locks utilized. The first is the low level lock (priv->low_lock) 98 There are two locks utilized. The first is the low level lock (priv->low_lock)
99 that protects the following: 99 that protects the following:
100 100
101 - Access to the Tx/Rx queue lists via priv->low_lock. The lists are as follows: 101 - Access to the Tx/Rx queue lists via priv->low_lock. The lists are as follows:
102 102
103 tx_free_list : Holds pre-allocated Tx buffers. 103 tx_free_list : Holds pre-allocated Tx buffers.
104 TAIL modified in __ipw2100_tx_process() 104 TAIL modified in __ipw2100_tx_process()
105 HEAD modified in ipw2100_tx() 105 HEAD modified in ipw2100_tx()
106 106
107 tx_pend_list : Holds used Tx buffers waiting to go into the TBD ring 107 tx_pend_list : Holds used Tx buffers waiting to go into the TBD ring
108 TAIL modified ipw2100_tx() 108 TAIL modified ipw2100_tx()
109 HEAD modified by ipw2100_tx_send_data() 109 HEAD modified by ipw2100_tx_send_data()
110 110
111 msg_free_list : Holds pre-allocated Msg (Command) buffers 111 msg_free_list : Holds pre-allocated Msg (Command) buffers
112 TAIL modified in __ipw2100_tx_process() 112 TAIL modified in __ipw2100_tx_process()
113 HEAD modified in ipw2100_hw_send_command() 113 HEAD modified in ipw2100_hw_send_command()
114 114
115 msg_pend_list : Holds used Msg buffers waiting to go into the TBD ring 115 msg_pend_list : Holds used Msg buffers waiting to go into the TBD ring
116 TAIL modified in ipw2100_hw_send_command() 116 TAIL modified in ipw2100_hw_send_command()
117 HEAD modified in ipw2100_tx_send_commands() 117 HEAD modified in ipw2100_tx_send_commands()
118 118
119 The flow of data on the TX side is as follows: 119 The flow of data on the TX side is as follows:
120 120
121 MSG_FREE_LIST + COMMAND => MSG_PEND_LIST => TBD => MSG_FREE_LIST 121 MSG_FREE_LIST + COMMAND => MSG_PEND_LIST => TBD => MSG_FREE_LIST
122 TX_FREE_LIST + DATA => TX_PEND_LIST => TBD => TX_FREE_LIST 122 TX_FREE_LIST + DATA => TX_PEND_LIST => TBD => TX_FREE_LIST
123 123
124 The methods that work on the TBD ring are protected via priv->low_lock. 124 The methods that work on the TBD ring are protected via priv->low_lock.
125 125
126 - The internal data state of the device itself 126 - The internal data state of the device itself
127 - Access to the firmware read/write indexes for the BD queues 127 - Access to the firmware read/write indexes for the BD queues
128 and associated logic 128 and associated logic
129 129
130 All external entry functions are locked with the priv->action_lock to ensure 130 All external entry functions are locked with the priv->action_lock to ensure
131 that only one external action is invoked at a time. 131 that only one external action is invoked at a time.
132 132
133 133
134 */ 134 */
135 135
136 #include <linux/compiler.h> 136 #include <linux/compiler.h>
137 #include <linux/errno.h> 137 #include <linux/errno.h>
138 #include <linux/if_arp.h> 138 #include <linux/if_arp.h>
139 #include <linux/in6.h> 139 #include <linux/in6.h>
140 #include <linux/in.h> 140 #include <linux/in.h>
141 #include <linux/ip.h> 141 #include <linux/ip.h>
142 #include <linux/kernel.h> 142 #include <linux/kernel.h>
143 #include <linux/kmod.h> 143 #include <linux/kmod.h>
144 #include <linux/module.h> 144 #include <linux/module.h>
145 #include <linux/netdevice.h> 145 #include <linux/netdevice.h>
146 #include <linux/ethtool.h> 146 #include <linux/ethtool.h>
147 #include <linux/pci.h> 147 #include <linux/pci.h>
148 #include <linux/dma-mapping.h> 148 #include <linux/dma-mapping.h>
149 #include <linux/proc_fs.h> 149 #include <linux/proc_fs.h>
150 #include <linux/skbuff.h> 150 #include <linux/skbuff.h>
151 #include <asm/uaccess.h> 151 #include <asm/uaccess.h>
152 #include <asm/io.h> 152 #include <asm/io.h>
153 #include <linux/fs.h> 153 #include <linux/fs.h>
154 #include <linux/mm.h> 154 #include <linux/mm.h>
155 #include <linux/slab.h> 155 #include <linux/slab.h>
156 #include <linux/unistd.h> 156 #include <linux/unistd.h>
157 #include <linux/stringify.h> 157 #include <linux/stringify.h>
158 #include <linux/tcp.h> 158 #include <linux/tcp.h>
159 #include <linux/types.h> 159 #include <linux/types.h>
160 #include <linux/time.h> 160 #include <linux/time.h>
161 #include <linux/firmware.h> 161 #include <linux/firmware.h>
162 #include <linux/acpi.h> 162 #include <linux/acpi.h>
163 #include <linux/ctype.h> 163 #include <linux/ctype.h>
164 #include <linux/pm_qos.h> 164 #include <linux/pm_qos.h>
165 165
166 #include <net/lib80211.h> 166 #include <net/lib80211.h>
167 167
168 #include "ipw2100.h" 168 #include "ipw2100.h"
169 169
170 #define IPW2100_VERSION "git-1.2.2" 170 #define IPW2100_VERSION "git-1.2.2"
171 171
172 #define DRV_NAME "ipw2100" 172 #define DRV_NAME "ipw2100"
173 #define DRV_VERSION IPW2100_VERSION 173 #define DRV_VERSION IPW2100_VERSION
174 #define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2100 Network Driver" 174 #define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2100 Network Driver"
175 #define DRV_COPYRIGHT "Copyright(c) 2003-2006 Intel Corporation" 175 #define DRV_COPYRIGHT "Copyright(c) 2003-2006 Intel Corporation"
176 176
177 static struct pm_qos_request_list ipw2100_pm_qos_req; 177 static struct pm_qos_request ipw2100_pm_qos_req;
178 178
179 /* Debugging stuff */ 179 /* Debugging stuff */
180 #ifdef CONFIG_IPW2100_DEBUG 180 #ifdef CONFIG_IPW2100_DEBUG
181 #define IPW2100_RX_DEBUG /* Reception debugging */ 181 #define IPW2100_RX_DEBUG /* Reception debugging */
182 #endif 182 #endif
183 183
184 MODULE_DESCRIPTION(DRV_DESCRIPTION); 184 MODULE_DESCRIPTION(DRV_DESCRIPTION);
185 MODULE_VERSION(DRV_VERSION); 185 MODULE_VERSION(DRV_VERSION);
186 MODULE_AUTHOR(DRV_COPYRIGHT); 186 MODULE_AUTHOR(DRV_COPYRIGHT);
187 MODULE_LICENSE("GPL"); 187 MODULE_LICENSE("GPL");
188 188
189 static int debug = 0; 189 static int debug = 0;
190 static int network_mode = 0; 190 static int network_mode = 0;
191 static int channel = 0; 191 static int channel = 0;
192 static int associate = 0; 192 static int associate = 0;
193 static int disable = 0; 193 static int disable = 0;
194 #ifdef CONFIG_PM 194 #ifdef CONFIG_PM
195 static struct ipw2100_fw ipw2100_firmware; 195 static struct ipw2100_fw ipw2100_firmware;
196 #endif 196 #endif
197 197
198 #include <linux/moduleparam.h> 198 #include <linux/moduleparam.h>
199 module_param(debug, int, 0444); 199 module_param(debug, int, 0444);
200 module_param_named(mode, network_mode, int, 0444); 200 module_param_named(mode, network_mode, int, 0444);
201 module_param(channel, int, 0444); 201 module_param(channel, int, 0444);
202 module_param(associate, int, 0444); 202 module_param(associate, int, 0444);
203 module_param(disable, int, 0444); 203 module_param(disable, int, 0444);
204 204
205 MODULE_PARM_DESC(debug, "debug level"); 205 MODULE_PARM_DESC(debug, "debug level");
206 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)"); 206 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
207 MODULE_PARM_DESC(channel, "channel"); 207 MODULE_PARM_DESC(channel, "channel");
208 MODULE_PARM_DESC(associate, "auto associate when scanning (default off)"); 208 MODULE_PARM_DESC(associate, "auto associate when scanning (default off)");
209 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])"); 209 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
210 210
211 static u32 ipw2100_debug_level = IPW_DL_NONE; 211 static u32 ipw2100_debug_level = IPW_DL_NONE;
212 212
213 #ifdef CONFIG_IPW2100_DEBUG 213 #ifdef CONFIG_IPW2100_DEBUG
214 #define IPW_DEBUG(level, message...) \ 214 #define IPW_DEBUG(level, message...) \
215 do { \ 215 do { \
216 if (ipw2100_debug_level & (level)) { \ 216 if (ipw2100_debug_level & (level)) { \
217 printk(KERN_DEBUG "ipw2100: %c %s ", \ 217 printk(KERN_DEBUG "ipw2100: %c %s ", \
218 in_interrupt() ? 'I' : 'U', __func__); \ 218 in_interrupt() ? 'I' : 'U', __func__); \
219 printk(message); \ 219 printk(message); \
220 } \ 220 } \
221 } while (0) 221 } while (0)
222 #else 222 #else
223 #define IPW_DEBUG(level, message...) do {} while (0) 223 #define IPW_DEBUG(level, message...) do {} while (0)
224 #endif /* CONFIG_IPW2100_DEBUG */ 224 #endif /* CONFIG_IPW2100_DEBUG */
225 225
226 #ifdef CONFIG_IPW2100_DEBUG 226 #ifdef CONFIG_IPW2100_DEBUG
227 static const char *command_types[] = { 227 static const char *command_types[] = {
228 "undefined", 228 "undefined",
229 "unused", /* HOST_ATTENTION */ 229 "unused", /* HOST_ATTENTION */
230 "HOST_COMPLETE", 230 "HOST_COMPLETE",
231 "unused", /* SLEEP */ 231 "unused", /* SLEEP */
232 "unused", /* HOST_POWER_DOWN */ 232 "unused", /* HOST_POWER_DOWN */
233 "unused", 233 "unused",
234 "SYSTEM_CONFIG", 234 "SYSTEM_CONFIG",
235 "unused", /* SET_IMR */ 235 "unused", /* SET_IMR */
236 "SSID", 236 "SSID",
237 "MANDATORY_BSSID", 237 "MANDATORY_BSSID",
238 "AUTHENTICATION_TYPE", 238 "AUTHENTICATION_TYPE",
239 "ADAPTER_ADDRESS", 239 "ADAPTER_ADDRESS",
240 "PORT_TYPE", 240 "PORT_TYPE",
241 "INTERNATIONAL_MODE", 241 "INTERNATIONAL_MODE",
242 "CHANNEL", 242 "CHANNEL",
243 "RTS_THRESHOLD", 243 "RTS_THRESHOLD",
244 "FRAG_THRESHOLD", 244 "FRAG_THRESHOLD",
245 "POWER_MODE", 245 "POWER_MODE",
246 "TX_RATES", 246 "TX_RATES",
247 "BASIC_TX_RATES", 247 "BASIC_TX_RATES",
248 "WEP_KEY_INFO", 248 "WEP_KEY_INFO",
249 "unused", 249 "unused",
250 "unused", 250 "unused",
251 "unused", 251 "unused",
252 "unused", 252 "unused",
253 "WEP_KEY_INDEX", 253 "WEP_KEY_INDEX",
254 "WEP_FLAGS", 254 "WEP_FLAGS",
255 "ADD_MULTICAST", 255 "ADD_MULTICAST",
256 "CLEAR_ALL_MULTICAST", 256 "CLEAR_ALL_MULTICAST",
257 "BEACON_INTERVAL", 257 "BEACON_INTERVAL",
258 "ATIM_WINDOW", 258 "ATIM_WINDOW",
259 "CLEAR_STATISTICS", 259 "CLEAR_STATISTICS",
260 "undefined", 260 "undefined",
261 "undefined", 261 "undefined",
262 "undefined", 262 "undefined",
263 "undefined", 263 "undefined",
264 "TX_POWER_INDEX", 264 "TX_POWER_INDEX",
265 "undefined", 265 "undefined",
266 "undefined", 266 "undefined",
267 "undefined", 267 "undefined",
268 "undefined", 268 "undefined",
269 "undefined", 269 "undefined",
270 "undefined", 270 "undefined",
271 "BROADCAST_SCAN", 271 "BROADCAST_SCAN",
272 "CARD_DISABLE", 272 "CARD_DISABLE",
273 "PREFERRED_BSSID", 273 "PREFERRED_BSSID",
274 "SET_SCAN_OPTIONS", 274 "SET_SCAN_OPTIONS",
275 "SCAN_DWELL_TIME", 275 "SCAN_DWELL_TIME",
276 "SWEEP_TABLE", 276 "SWEEP_TABLE",
277 "AP_OR_STATION_TABLE", 277 "AP_OR_STATION_TABLE",
278 "GROUP_ORDINALS", 278 "GROUP_ORDINALS",
279 "SHORT_RETRY_LIMIT", 279 "SHORT_RETRY_LIMIT",
280 "LONG_RETRY_LIMIT", 280 "LONG_RETRY_LIMIT",
281 "unused", /* SAVE_CALIBRATION */ 281 "unused", /* SAVE_CALIBRATION */
282 "unused", /* RESTORE_CALIBRATION */ 282 "unused", /* RESTORE_CALIBRATION */
283 "undefined", 283 "undefined",
284 "undefined", 284 "undefined",
285 "undefined", 285 "undefined",
286 "HOST_PRE_POWER_DOWN", 286 "HOST_PRE_POWER_DOWN",
287 "unused", /* HOST_INTERRUPT_COALESCING */ 287 "unused", /* HOST_INTERRUPT_COALESCING */
288 "undefined", 288 "undefined",
289 "CARD_DISABLE_PHY_OFF", 289 "CARD_DISABLE_PHY_OFF",
290 "MSDU_TX_RATES", 290 "MSDU_TX_RATES",
291 "undefined", 291 "undefined",
292 "SET_STATION_STAT_BITS", 292 "SET_STATION_STAT_BITS",
293 "CLEAR_STATIONS_STAT_BITS", 293 "CLEAR_STATIONS_STAT_BITS",
294 "LEAP_ROGUE_MODE", 294 "LEAP_ROGUE_MODE",
295 "SET_SECURITY_INFORMATION", 295 "SET_SECURITY_INFORMATION",
296 "DISASSOCIATION_BSSID", 296 "DISASSOCIATION_BSSID",
297 "SET_WPA_ASS_IE" 297 "SET_WPA_ASS_IE"
298 }; 298 };
299 #endif 299 #endif
300 300
301 #define WEXT_USECHANNELS 1 301 #define WEXT_USECHANNELS 1
302 302
303 static const long ipw2100_frequencies[] = { 303 static const long ipw2100_frequencies[] = {
304 2412, 2417, 2422, 2427, 304 2412, 2417, 2422, 2427,
305 2432, 2437, 2442, 2447, 305 2432, 2437, 2442, 2447,
306 2452, 2457, 2462, 2467, 306 2452, 2457, 2462, 2467,
307 2472, 2484 307 2472, 2484
308 }; 308 };
309 309
310 #define FREQ_COUNT ARRAY_SIZE(ipw2100_frequencies) 310 #define FREQ_COUNT ARRAY_SIZE(ipw2100_frequencies)
311 311
312 static const long ipw2100_rates_11b[] = { 312 static const long ipw2100_rates_11b[] = {
313 1000000, 313 1000000,
314 2000000, 314 2000000,
315 5500000, 315 5500000,
316 11000000 316 11000000
317 }; 317 };
318 318
319 static struct ieee80211_rate ipw2100_bg_rates[] = { 319 static struct ieee80211_rate ipw2100_bg_rates[] = {
320 { .bitrate = 10 }, 320 { .bitrate = 10 },
321 { .bitrate = 20, .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 321 { .bitrate = 20, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
322 { .bitrate = 55, .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 322 { .bitrate = 55, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
323 { .bitrate = 110, .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 323 { .bitrate = 110, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
324 }; 324 };
325 325
326 #define RATE_COUNT ARRAY_SIZE(ipw2100_rates_11b) 326 #define RATE_COUNT ARRAY_SIZE(ipw2100_rates_11b)
327 327
328 /* Pre-decl until we get the code solid and then we can clean it up */ 328 /* Pre-decl until we get the code solid and then we can clean it up */
329 static void ipw2100_tx_send_commands(struct ipw2100_priv *priv); 329 static void ipw2100_tx_send_commands(struct ipw2100_priv *priv);
330 static void ipw2100_tx_send_data(struct ipw2100_priv *priv); 330 static void ipw2100_tx_send_data(struct ipw2100_priv *priv);
331 static int ipw2100_adapter_setup(struct ipw2100_priv *priv); 331 static int ipw2100_adapter_setup(struct ipw2100_priv *priv);
332 332
333 static void ipw2100_queues_initialize(struct ipw2100_priv *priv); 333 static void ipw2100_queues_initialize(struct ipw2100_priv *priv);
334 static void ipw2100_queues_free(struct ipw2100_priv *priv); 334 static void ipw2100_queues_free(struct ipw2100_priv *priv);
335 static int ipw2100_queues_allocate(struct ipw2100_priv *priv); 335 static int ipw2100_queues_allocate(struct ipw2100_priv *priv);
336 336
337 static int ipw2100_fw_download(struct ipw2100_priv *priv, 337 static int ipw2100_fw_download(struct ipw2100_priv *priv,
338 struct ipw2100_fw *fw); 338 struct ipw2100_fw *fw);
339 static int ipw2100_get_firmware(struct ipw2100_priv *priv, 339 static int ipw2100_get_firmware(struct ipw2100_priv *priv,
340 struct ipw2100_fw *fw); 340 struct ipw2100_fw *fw);
341 static int ipw2100_get_fwversion(struct ipw2100_priv *priv, char *buf, 341 static int ipw2100_get_fwversion(struct ipw2100_priv *priv, char *buf,
342 size_t max); 342 size_t max);
343 static int ipw2100_get_ucodeversion(struct ipw2100_priv *priv, char *buf, 343 static int ipw2100_get_ucodeversion(struct ipw2100_priv *priv, char *buf,
344 size_t max); 344 size_t max);
345 static void ipw2100_release_firmware(struct ipw2100_priv *priv, 345 static void ipw2100_release_firmware(struct ipw2100_priv *priv,
346 struct ipw2100_fw *fw); 346 struct ipw2100_fw *fw);
347 static int ipw2100_ucode_download(struct ipw2100_priv *priv, 347 static int ipw2100_ucode_download(struct ipw2100_priv *priv,
348 struct ipw2100_fw *fw); 348 struct ipw2100_fw *fw);
349 static void ipw2100_wx_event_work(struct work_struct *work); 349 static void ipw2100_wx_event_work(struct work_struct *work);
350 static struct iw_statistics *ipw2100_wx_wireless_stats(struct net_device *dev); 350 static struct iw_statistics *ipw2100_wx_wireless_stats(struct net_device *dev);
351 static struct iw_handler_def ipw2100_wx_handler_def; 351 static struct iw_handler_def ipw2100_wx_handler_def;
352 352
353 static inline void read_register(struct net_device *dev, u32 reg, u32 * val) 353 static inline void read_register(struct net_device *dev, u32 reg, u32 * val)
354 { 354 {
355 *val = readl((void __iomem *)(dev->base_addr + reg)); 355 *val = readl((void __iomem *)(dev->base_addr + reg));
356 IPW_DEBUG_IO("r: 0x%08X => 0x%08X\n", reg, *val); 356 IPW_DEBUG_IO("r: 0x%08X => 0x%08X\n", reg, *val);
357 } 357 }
358 358
359 static inline void write_register(struct net_device *dev, u32 reg, u32 val) 359 static inline void write_register(struct net_device *dev, u32 reg, u32 val)
360 { 360 {
361 writel(val, (void __iomem *)(dev->base_addr + reg)); 361 writel(val, (void __iomem *)(dev->base_addr + reg));
362 IPW_DEBUG_IO("w: 0x%08X <= 0x%08X\n", reg, val); 362 IPW_DEBUG_IO("w: 0x%08X <= 0x%08X\n", reg, val);
363 } 363 }
364 364
365 static inline void read_register_word(struct net_device *dev, u32 reg, 365 static inline void read_register_word(struct net_device *dev, u32 reg,
366 u16 * val) 366 u16 * val)
367 { 367 {
368 *val = readw((void __iomem *)(dev->base_addr + reg)); 368 *val = readw((void __iomem *)(dev->base_addr + reg));
369 IPW_DEBUG_IO("r: 0x%08X => %04X\n", reg, *val); 369 IPW_DEBUG_IO("r: 0x%08X => %04X\n", reg, *val);
370 } 370 }
371 371
372 static inline void read_register_byte(struct net_device *dev, u32 reg, u8 * val) 372 static inline void read_register_byte(struct net_device *dev, u32 reg, u8 * val)
373 { 373 {
374 *val = readb((void __iomem *)(dev->base_addr + reg)); 374 *val = readb((void __iomem *)(dev->base_addr + reg));
375 IPW_DEBUG_IO("r: 0x%08X => %02X\n", reg, *val); 375 IPW_DEBUG_IO("r: 0x%08X => %02X\n", reg, *val);
376 } 376 }
377 377
378 static inline void write_register_word(struct net_device *dev, u32 reg, u16 val) 378 static inline void write_register_word(struct net_device *dev, u32 reg, u16 val)
379 { 379 {
380 writew(val, (void __iomem *)(dev->base_addr + reg)); 380 writew(val, (void __iomem *)(dev->base_addr + reg));
381 IPW_DEBUG_IO("w: 0x%08X <= %04X\n", reg, val); 381 IPW_DEBUG_IO("w: 0x%08X <= %04X\n", reg, val);
382 } 382 }
383 383
384 static inline void write_register_byte(struct net_device *dev, u32 reg, u8 val) 384 static inline void write_register_byte(struct net_device *dev, u32 reg, u8 val)
385 { 385 {
386 writeb(val, (void __iomem *)(dev->base_addr + reg)); 386 writeb(val, (void __iomem *)(dev->base_addr + reg));
387 IPW_DEBUG_IO("w: 0x%08X =< %02X\n", reg, val); 387 IPW_DEBUG_IO("w: 0x%08X =< %02X\n", reg, val);
388 } 388 }
389 389
390 static inline void read_nic_dword(struct net_device *dev, u32 addr, u32 * val) 390 static inline void read_nic_dword(struct net_device *dev, u32 addr, u32 * val)
391 { 391 {
392 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, 392 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
393 addr & IPW_REG_INDIRECT_ADDR_MASK); 393 addr & IPW_REG_INDIRECT_ADDR_MASK);
394 read_register(dev, IPW_REG_INDIRECT_ACCESS_DATA, val); 394 read_register(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
395 } 395 }
396 396
397 static inline void write_nic_dword(struct net_device *dev, u32 addr, u32 val) 397 static inline void write_nic_dword(struct net_device *dev, u32 addr, u32 val)
398 { 398 {
399 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, 399 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
400 addr & IPW_REG_INDIRECT_ADDR_MASK); 400 addr & IPW_REG_INDIRECT_ADDR_MASK);
401 write_register(dev, IPW_REG_INDIRECT_ACCESS_DATA, val); 401 write_register(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
402 } 402 }
403 403
404 static inline void read_nic_word(struct net_device *dev, u32 addr, u16 * val) 404 static inline void read_nic_word(struct net_device *dev, u32 addr, u16 * val)
405 { 405 {
406 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, 406 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
407 addr & IPW_REG_INDIRECT_ADDR_MASK); 407 addr & IPW_REG_INDIRECT_ADDR_MASK);
408 read_register_word(dev, IPW_REG_INDIRECT_ACCESS_DATA, val); 408 read_register_word(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
409 } 409 }
410 410
411 static inline void write_nic_word(struct net_device *dev, u32 addr, u16 val) 411 static inline void write_nic_word(struct net_device *dev, u32 addr, u16 val)
412 { 412 {
413 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, 413 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
414 addr & IPW_REG_INDIRECT_ADDR_MASK); 414 addr & IPW_REG_INDIRECT_ADDR_MASK);
415 write_register_word(dev, IPW_REG_INDIRECT_ACCESS_DATA, val); 415 write_register_word(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
416 } 416 }
417 417
418 static inline void read_nic_byte(struct net_device *dev, u32 addr, u8 * val) 418 static inline void read_nic_byte(struct net_device *dev, u32 addr, u8 * val)
419 { 419 {
420 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, 420 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
421 addr & IPW_REG_INDIRECT_ADDR_MASK); 421 addr & IPW_REG_INDIRECT_ADDR_MASK);
422 read_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA, val); 422 read_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
423 } 423 }
424 424
425 static inline void write_nic_byte(struct net_device *dev, u32 addr, u8 val) 425 static inline void write_nic_byte(struct net_device *dev, u32 addr, u8 val)
426 { 426 {
427 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, 427 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
428 addr & IPW_REG_INDIRECT_ADDR_MASK); 428 addr & IPW_REG_INDIRECT_ADDR_MASK);
429 write_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA, val); 429 write_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
430 } 430 }
431 431
432 static inline void write_nic_auto_inc_address(struct net_device *dev, u32 addr) 432 static inline void write_nic_auto_inc_address(struct net_device *dev, u32 addr)
433 { 433 {
434 write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS, 434 write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS,
435 addr & IPW_REG_INDIRECT_ADDR_MASK); 435 addr & IPW_REG_INDIRECT_ADDR_MASK);
436 } 436 }
437 437
438 static inline void write_nic_dword_auto_inc(struct net_device *dev, u32 val) 438 static inline void write_nic_dword_auto_inc(struct net_device *dev, u32 val)
439 { 439 {
440 write_register(dev, IPW_REG_AUTOINCREMENT_DATA, val); 440 write_register(dev, IPW_REG_AUTOINCREMENT_DATA, val);
441 } 441 }
442 442
443 static void write_nic_memory(struct net_device *dev, u32 addr, u32 len, 443 static void write_nic_memory(struct net_device *dev, u32 addr, u32 len,
444 const u8 * buf) 444 const u8 * buf)
445 { 445 {
446 u32 aligned_addr; 446 u32 aligned_addr;
447 u32 aligned_len; 447 u32 aligned_len;
448 u32 dif_len; 448 u32 dif_len;
449 u32 i; 449 u32 i;
450 450
451 /* read first nibble byte by byte */ 451 /* read first nibble byte by byte */
452 aligned_addr = addr & (~0x3); 452 aligned_addr = addr & (~0x3);
453 dif_len = addr - aligned_addr; 453 dif_len = addr - aligned_addr;
454 if (dif_len) { 454 if (dif_len) {
455 /* Start reading at aligned_addr + dif_len */ 455 /* Start reading at aligned_addr + dif_len */
456 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, 456 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
457 aligned_addr); 457 aligned_addr);
458 for (i = dif_len; i < 4; i++, buf++) 458 for (i = dif_len; i < 4; i++, buf++)
459 write_register_byte(dev, 459 write_register_byte(dev,
460 IPW_REG_INDIRECT_ACCESS_DATA + i, 460 IPW_REG_INDIRECT_ACCESS_DATA + i,
461 *buf); 461 *buf);
462 462
463 len -= dif_len; 463 len -= dif_len;
464 aligned_addr += 4; 464 aligned_addr += 4;
465 } 465 }
466 466
467 /* read DWs through autoincrement registers */ 467 /* read DWs through autoincrement registers */
468 write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS, aligned_addr); 468 write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS, aligned_addr);
469 aligned_len = len & (~0x3); 469 aligned_len = len & (~0x3);
470 for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4) 470 for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4)
471 write_register(dev, IPW_REG_AUTOINCREMENT_DATA, *(u32 *) buf); 471 write_register(dev, IPW_REG_AUTOINCREMENT_DATA, *(u32 *) buf);
472 472
473 /* copy the last nibble */ 473 /* copy the last nibble */
474 dif_len = len - aligned_len; 474 dif_len = len - aligned_len;
475 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, aligned_addr); 475 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, aligned_addr);
476 for (i = 0; i < dif_len; i++, buf++) 476 for (i = 0; i < dif_len; i++, buf++)
477 write_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA + i, 477 write_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA + i,
478 *buf); 478 *buf);
479 } 479 }
480 480
481 static void read_nic_memory(struct net_device *dev, u32 addr, u32 len, 481 static void read_nic_memory(struct net_device *dev, u32 addr, u32 len,
482 u8 * buf) 482 u8 * buf)
483 { 483 {
484 u32 aligned_addr; 484 u32 aligned_addr;
485 u32 aligned_len; 485 u32 aligned_len;
486 u32 dif_len; 486 u32 dif_len;
487 u32 i; 487 u32 i;
488 488
489 /* read first nibble byte by byte */ 489 /* read first nibble byte by byte */
490 aligned_addr = addr & (~0x3); 490 aligned_addr = addr & (~0x3);
491 dif_len = addr - aligned_addr; 491 dif_len = addr - aligned_addr;
492 if (dif_len) { 492 if (dif_len) {
493 /* Start reading at aligned_addr + dif_len */ 493 /* Start reading at aligned_addr + dif_len */
494 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, 494 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
495 aligned_addr); 495 aligned_addr);
496 for (i = dif_len; i < 4; i++, buf++) 496 for (i = dif_len; i < 4; i++, buf++)
497 read_register_byte(dev, 497 read_register_byte(dev,
498 IPW_REG_INDIRECT_ACCESS_DATA + i, 498 IPW_REG_INDIRECT_ACCESS_DATA + i,
499 buf); 499 buf);
500 500
501 len -= dif_len; 501 len -= dif_len;
502 aligned_addr += 4; 502 aligned_addr += 4;
503 } 503 }
504 504
505 /* read DWs through autoincrement registers */ 505 /* read DWs through autoincrement registers */
506 write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS, aligned_addr); 506 write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS, aligned_addr);
507 aligned_len = len & (~0x3); 507 aligned_len = len & (~0x3);
508 for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4) 508 for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4)
509 read_register(dev, IPW_REG_AUTOINCREMENT_DATA, (u32 *) buf); 509 read_register(dev, IPW_REG_AUTOINCREMENT_DATA, (u32 *) buf);
510 510
511 /* copy the last nibble */ 511 /* copy the last nibble */
512 dif_len = len - aligned_len; 512 dif_len = len - aligned_len;
513 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, aligned_addr); 513 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, aligned_addr);
514 for (i = 0; i < dif_len; i++, buf++) 514 for (i = 0; i < dif_len; i++, buf++)
515 read_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA + i, buf); 515 read_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA + i, buf);
516 } 516 }
517 517
518 static inline int ipw2100_hw_is_adapter_in_system(struct net_device *dev) 518 static inline int ipw2100_hw_is_adapter_in_system(struct net_device *dev)
519 { 519 {
520 return (dev->base_addr && 520 return (dev->base_addr &&
521 (readl 521 (readl
522 ((void __iomem *)(dev->base_addr + 522 ((void __iomem *)(dev->base_addr +
523 IPW_REG_DOA_DEBUG_AREA_START)) 523 IPW_REG_DOA_DEBUG_AREA_START))
524 == IPW_DATA_DOA_DEBUG_VALUE)); 524 == IPW_DATA_DOA_DEBUG_VALUE));
525 } 525 }
526 526
527 static int ipw2100_get_ordinal(struct ipw2100_priv *priv, u32 ord, 527 static int ipw2100_get_ordinal(struct ipw2100_priv *priv, u32 ord,
528 void *val, u32 * len) 528 void *val, u32 * len)
529 { 529 {
530 struct ipw2100_ordinals *ordinals = &priv->ordinals; 530 struct ipw2100_ordinals *ordinals = &priv->ordinals;
531 u32 addr; 531 u32 addr;
532 u32 field_info; 532 u32 field_info;
533 u16 field_len; 533 u16 field_len;
534 u16 field_count; 534 u16 field_count;
535 u32 total_length; 535 u32 total_length;
536 536
537 if (ordinals->table1_addr == 0) { 537 if (ordinals->table1_addr == 0) {
538 printk(KERN_WARNING DRV_NAME ": attempt to use fw ordinals " 538 printk(KERN_WARNING DRV_NAME ": attempt to use fw ordinals "
539 "before they have been loaded.\n"); 539 "before they have been loaded.\n");
540 return -EINVAL; 540 return -EINVAL;
541 } 541 }
542 542
543 if (IS_ORDINAL_TABLE_ONE(ordinals, ord)) { 543 if (IS_ORDINAL_TABLE_ONE(ordinals, ord)) {
544 if (*len < IPW_ORD_TAB_1_ENTRY_SIZE) { 544 if (*len < IPW_ORD_TAB_1_ENTRY_SIZE) {
545 *len = IPW_ORD_TAB_1_ENTRY_SIZE; 545 *len = IPW_ORD_TAB_1_ENTRY_SIZE;
546 546
547 printk(KERN_WARNING DRV_NAME 547 printk(KERN_WARNING DRV_NAME
548 ": ordinal buffer length too small, need %zd\n", 548 ": ordinal buffer length too small, need %zd\n",
549 IPW_ORD_TAB_1_ENTRY_SIZE); 549 IPW_ORD_TAB_1_ENTRY_SIZE);
550 550
551 return -EINVAL; 551 return -EINVAL;
552 } 552 }
553 553
554 read_nic_dword(priv->net_dev, 554 read_nic_dword(priv->net_dev,
555 ordinals->table1_addr + (ord << 2), &addr); 555 ordinals->table1_addr + (ord << 2), &addr);
556 read_nic_dword(priv->net_dev, addr, val); 556 read_nic_dword(priv->net_dev, addr, val);
557 557
558 *len = IPW_ORD_TAB_1_ENTRY_SIZE; 558 *len = IPW_ORD_TAB_1_ENTRY_SIZE;
559 559
560 return 0; 560 return 0;
561 } 561 }
562 562
563 if (IS_ORDINAL_TABLE_TWO(ordinals, ord)) { 563 if (IS_ORDINAL_TABLE_TWO(ordinals, ord)) {
564 564
565 ord -= IPW_START_ORD_TAB_2; 565 ord -= IPW_START_ORD_TAB_2;
566 566
567 /* get the address of statistic */ 567 /* get the address of statistic */
568 read_nic_dword(priv->net_dev, 568 read_nic_dword(priv->net_dev,
569 ordinals->table2_addr + (ord << 3), &addr); 569 ordinals->table2_addr + (ord << 3), &addr);
570 570
571 /* get the second DW of statistics ; 571 /* get the second DW of statistics ;
572 * two 16-bit words - first is length, second is count */ 572 * two 16-bit words - first is length, second is count */
573 read_nic_dword(priv->net_dev, 573 read_nic_dword(priv->net_dev,
574 ordinals->table2_addr + (ord << 3) + sizeof(u32), 574 ordinals->table2_addr + (ord << 3) + sizeof(u32),
575 &field_info); 575 &field_info);
576 576
577 /* get each entry length */ 577 /* get each entry length */
578 field_len = *((u16 *) & field_info); 578 field_len = *((u16 *) & field_info);
579 579
580 /* get number of entries */ 580 /* get number of entries */
581 field_count = *(((u16 *) & field_info) + 1); 581 field_count = *(((u16 *) & field_info) + 1);
582 582
583 /* abort if no enough memory */ 583 /* abort if no enough memory */
584 total_length = field_len * field_count; 584 total_length = field_len * field_count;
585 if (total_length > *len) { 585 if (total_length > *len) {
586 *len = total_length; 586 *len = total_length;
587 return -EINVAL; 587 return -EINVAL;
588 } 588 }
589 589
590 *len = total_length; 590 *len = total_length;
591 if (!total_length) 591 if (!total_length)
592 return 0; 592 return 0;
593 593
594 /* read the ordinal data from the SRAM */ 594 /* read the ordinal data from the SRAM */
595 read_nic_memory(priv->net_dev, addr, total_length, val); 595 read_nic_memory(priv->net_dev, addr, total_length, val);
596 596
597 return 0; 597 return 0;
598 } 598 }
599 599
600 printk(KERN_WARNING DRV_NAME ": ordinal %d neither in table 1 nor " 600 printk(KERN_WARNING DRV_NAME ": ordinal %d neither in table 1 nor "
601 "in table 2\n", ord); 601 "in table 2\n", ord);
602 602
603 return -EINVAL; 603 return -EINVAL;
604 } 604 }
605 605
606 static int ipw2100_set_ordinal(struct ipw2100_priv *priv, u32 ord, u32 * val, 606 static int ipw2100_set_ordinal(struct ipw2100_priv *priv, u32 ord, u32 * val,
607 u32 * len) 607 u32 * len)
608 { 608 {
609 struct ipw2100_ordinals *ordinals = &priv->ordinals; 609 struct ipw2100_ordinals *ordinals = &priv->ordinals;
610 u32 addr; 610 u32 addr;
611 611
612 if (IS_ORDINAL_TABLE_ONE(ordinals, ord)) { 612 if (IS_ORDINAL_TABLE_ONE(ordinals, ord)) {
613 if (*len != IPW_ORD_TAB_1_ENTRY_SIZE) { 613 if (*len != IPW_ORD_TAB_1_ENTRY_SIZE) {
614 *len = IPW_ORD_TAB_1_ENTRY_SIZE; 614 *len = IPW_ORD_TAB_1_ENTRY_SIZE;
615 IPW_DEBUG_INFO("wrong size\n"); 615 IPW_DEBUG_INFO("wrong size\n");
616 return -EINVAL; 616 return -EINVAL;
617 } 617 }
618 618
619 read_nic_dword(priv->net_dev, 619 read_nic_dword(priv->net_dev,
620 ordinals->table1_addr + (ord << 2), &addr); 620 ordinals->table1_addr + (ord << 2), &addr);
621 621
622 write_nic_dword(priv->net_dev, addr, *val); 622 write_nic_dword(priv->net_dev, addr, *val);
623 623
624 *len = IPW_ORD_TAB_1_ENTRY_SIZE; 624 *len = IPW_ORD_TAB_1_ENTRY_SIZE;
625 625
626 return 0; 626 return 0;
627 } 627 }
628 628
629 IPW_DEBUG_INFO("wrong table\n"); 629 IPW_DEBUG_INFO("wrong table\n");
630 if (IS_ORDINAL_TABLE_TWO(ordinals, ord)) 630 if (IS_ORDINAL_TABLE_TWO(ordinals, ord))
631 return -EINVAL; 631 return -EINVAL;
632 632
633 return -EINVAL; 633 return -EINVAL;
634 } 634 }
635 635
636 static char *snprint_line(char *buf, size_t count, 636 static char *snprint_line(char *buf, size_t count,
637 const u8 * data, u32 len, u32 ofs) 637 const u8 * data, u32 len, u32 ofs)
638 { 638 {
639 int out, i, j, l; 639 int out, i, j, l;
640 char c; 640 char c;
641 641
642 out = snprintf(buf, count, "%08X", ofs); 642 out = snprintf(buf, count, "%08X", ofs);
643 643
644 for (l = 0, i = 0; i < 2; i++) { 644 for (l = 0, i = 0; i < 2; i++) {
645 out += snprintf(buf + out, count - out, " "); 645 out += snprintf(buf + out, count - out, " ");
646 for (j = 0; j < 8 && l < len; j++, l++) 646 for (j = 0; j < 8 && l < len; j++, l++)
647 out += snprintf(buf + out, count - out, "%02X ", 647 out += snprintf(buf + out, count - out, "%02X ",
648 data[(i * 8 + j)]); 648 data[(i * 8 + j)]);
649 for (; j < 8; j++) 649 for (; j < 8; j++)
650 out += snprintf(buf + out, count - out, " "); 650 out += snprintf(buf + out, count - out, " ");
651 } 651 }
652 652
653 out += snprintf(buf + out, count - out, " "); 653 out += snprintf(buf + out, count - out, " ");
654 for (l = 0, i = 0; i < 2; i++) { 654 for (l = 0, i = 0; i < 2; i++) {
655 out += snprintf(buf + out, count - out, " "); 655 out += snprintf(buf + out, count - out, " ");
656 for (j = 0; j < 8 && l < len; j++, l++) { 656 for (j = 0; j < 8 && l < len; j++, l++) {
657 c = data[(i * 8 + j)]; 657 c = data[(i * 8 + j)];
658 if (!isascii(c) || !isprint(c)) 658 if (!isascii(c) || !isprint(c))
659 c = '.'; 659 c = '.';
660 660
661 out += snprintf(buf + out, count - out, "%c", c); 661 out += snprintf(buf + out, count - out, "%c", c);
662 } 662 }
663 663
664 for (; j < 8; j++) 664 for (; j < 8; j++)
665 out += snprintf(buf + out, count - out, " "); 665 out += snprintf(buf + out, count - out, " ");
666 } 666 }
667 667
668 return buf; 668 return buf;
669 } 669 }
670 670
671 static void printk_buf(int level, const u8 * data, u32 len) 671 static void printk_buf(int level, const u8 * data, u32 len)
672 { 672 {
673 char line[81]; 673 char line[81];
674 u32 ofs = 0; 674 u32 ofs = 0;
675 if (!(ipw2100_debug_level & level)) 675 if (!(ipw2100_debug_level & level))
676 return; 676 return;
677 677
678 while (len) { 678 while (len) {
679 printk(KERN_DEBUG "%s\n", 679 printk(KERN_DEBUG "%s\n",
680 snprint_line(line, sizeof(line), &data[ofs], 680 snprint_line(line, sizeof(line), &data[ofs],
681 min(len, 16U), ofs)); 681 min(len, 16U), ofs));
682 ofs += 16; 682 ofs += 16;
683 len -= min(len, 16U); 683 len -= min(len, 16U);
684 } 684 }
685 } 685 }
686 686
687 #define MAX_RESET_BACKOFF 10 687 #define MAX_RESET_BACKOFF 10
688 688
689 static void schedule_reset(struct ipw2100_priv *priv) 689 static void schedule_reset(struct ipw2100_priv *priv)
690 { 690 {
691 unsigned long now = get_seconds(); 691 unsigned long now = get_seconds();
692 692
693 /* If we haven't received a reset request within the backoff period, 693 /* If we haven't received a reset request within the backoff period,
694 * then we can reset the backoff interval so this reset occurs 694 * then we can reset the backoff interval so this reset occurs
695 * immediately */ 695 * immediately */
696 if (priv->reset_backoff && 696 if (priv->reset_backoff &&
697 (now - priv->last_reset > priv->reset_backoff)) 697 (now - priv->last_reset > priv->reset_backoff))
698 priv->reset_backoff = 0; 698 priv->reset_backoff = 0;
699 699
700 priv->last_reset = get_seconds(); 700 priv->last_reset = get_seconds();
701 701
702 if (!(priv->status & STATUS_RESET_PENDING)) { 702 if (!(priv->status & STATUS_RESET_PENDING)) {
703 IPW_DEBUG_INFO("%s: Scheduling firmware restart (%ds).\n", 703 IPW_DEBUG_INFO("%s: Scheduling firmware restart (%ds).\n",
704 priv->net_dev->name, priv->reset_backoff); 704 priv->net_dev->name, priv->reset_backoff);
705 netif_carrier_off(priv->net_dev); 705 netif_carrier_off(priv->net_dev);
706 netif_stop_queue(priv->net_dev); 706 netif_stop_queue(priv->net_dev);
707 priv->status |= STATUS_RESET_PENDING; 707 priv->status |= STATUS_RESET_PENDING;
708 if (priv->reset_backoff) 708 if (priv->reset_backoff)
709 schedule_delayed_work(&priv->reset_work, 709 schedule_delayed_work(&priv->reset_work,
710 priv->reset_backoff * HZ); 710 priv->reset_backoff * HZ);
711 else 711 else
712 schedule_delayed_work(&priv->reset_work, 0); 712 schedule_delayed_work(&priv->reset_work, 0);
713 713
714 if (priv->reset_backoff < MAX_RESET_BACKOFF) 714 if (priv->reset_backoff < MAX_RESET_BACKOFF)
715 priv->reset_backoff++; 715 priv->reset_backoff++;
716 716
717 wake_up_interruptible(&priv->wait_command_queue); 717 wake_up_interruptible(&priv->wait_command_queue);
718 } else 718 } else
719 IPW_DEBUG_INFO("%s: Firmware restart already in progress.\n", 719 IPW_DEBUG_INFO("%s: Firmware restart already in progress.\n",
720 priv->net_dev->name); 720 priv->net_dev->name);
721 721
722 } 722 }
723 723
724 #define HOST_COMPLETE_TIMEOUT (2 * HZ) 724 #define HOST_COMPLETE_TIMEOUT (2 * HZ)
725 static int ipw2100_hw_send_command(struct ipw2100_priv *priv, 725 static int ipw2100_hw_send_command(struct ipw2100_priv *priv,
726 struct host_command *cmd) 726 struct host_command *cmd)
727 { 727 {
728 struct list_head *element; 728 struct list_head *element;
729 struct ipw2100_tx_packet *packet; 729 struct ipw2100_tx_packet *packet;
730 unsigned long flags; 730 unsigned long flags;
731 int err = 0; 731 int err = 0;
732 732
733 IPW_DEBUG_HC("Sending %s command (#%d), %d bytes\n", 733 IPW_DEBUG_HC("Sending %s command (#%d), %d bytes\n",
734 command_types[cmd->host_command], cmd->host_command, 734 command_types[cmd->host_command], cmd->host_command,
735 cmd->host_command_length); 735 cmd->host_command_length);
736 printk_buf(IPW_DL_HC, (u8 *) cmd->host_command_parameters, 736 printk_buf(IPW_DL_HC, (u8 *) cmd->host_command_parameters,
737 cmd->host_command_length); 737 cmd->host_command_length);
738 738
739 spin_lock_irqsave(&priv->low_lock, flags); 739 spin_lock_irqsave(&priv->low_lock, flags);
740 740
741 if (priv->fatal_error) { 741 if (priv->fatal_error) {
742 IPW_DEBUG_INFO 742 IPW_DEBUG_INFO
743 ("Attempt to send command while hardware in fatal error condition.\n"); 743 ("Attempt to send command while hardware in fatal error condition.\n");
744 err = -EIO; 744 err = -EIO;
745 goto fail_unlock; 745 goto fail_unlock;
746 } 746 }
747 747
748 if (!(priv->status & STATUS_RUNNING)) { 748 if (!(priv->status & STATUS_RUNNING)) {
749 IPW_DEBUG_INFO 749 IPW_DEBUG_INFO
750 ("Attempt to send command while hardware is not running.\n"); 750 ("Attempt to send command while hardware is not running.\n");
751 err = -EIO; 751 err = -EIO;
752 goto fail_unlock; 752 goto fail_unlock;
753 } 753 }
754 754
755 if (priv->status & STATUS_CMD_ACTIVE) { 755 if (priv->status & STATUS_CMD_ACTIVE) {
756 IPW_DEBUG_INFO 756 IPW_DEBUG_INFO
757 ("Attempt to send command while another command is pending.\n"); 757 ("Attempt to send command while another command is pending.\n");
758 err = -EBUSY; 758 err = -EBUSY;
759 goto fail_unlock; 759 goto fail_unlock;
760 } 760 }
761 761
762 if (list_empty(&priv->msg_free_list)) { 762 if (list_empty(&priv->msg_free_list)) {
763 IPW_DEBUG_INFO("no available msg buffers\n"); 763 IPW_DEBUG_INFO("no available msg buffers\n");
764 goto fail_unlock; 764 goto fail_unlock;
765 } 765 }
766 766
767 priv->status |= STATUS_CMD_ACTIVE; 767 priv->status |= STATUS_CMD_ACTIVE;
768 priv->messages_sent++; 768 priv->messages_sent++;
769 769
770 element = priv->msg_free_list.next; 770 element = priv->msg_free_list.next;
771 771
772 packet = list_entry(element, struct ipw2100_tx_packet, list); 772 packet = list_entry(element, struct ipw2100_tx_packet, list);
773 packet->jiffy_start = jiffies; 773 packet->jiffy_start = jiffies;
774 774
775 /* initialize the firmware command packet */ 775 /* initialize the firmware command packet */
776 packet->info.c_struct.cmd->host_command_reg = cmd->host_command; 776 packet->info.c_struct.cmd->host_command_reg = cmd->host_command;
777 packet->info.c_struct.cmd->host_command_reg1 = cmd->host_command1; 777 packet->info.c_struct.cmd->host_command_reg1 = cmd->host_command1;
778 packet->info.c_struct.cmd->host_command_len_reg = 778 packet->info.c_struct.cmd->host_command_len_reg =
779 cmd->host_command_length; 779 cmd->host_command_length;
780 packet->info.c_struct.cmd->sequence = cmd->host_command_sequence; 780 packet->info.c_struct.cmd->sequence = cmd->host_command_sequence;
781 781
782 memcpy(packet->info.c_struct.cmd->host_command_params_reg, 782 memcpy(packet->info.c_struct.cmd->host_command_params_reg,
783 cmd->host_command_parameters, 783 cmd->host_command_parameters,
784 sizeof(packet->info.c_struct.cmd->host_command_params_reg)); 784 sizeof(packet->info.c_struct.cmd->host_command_params_reg));
785 785
786 list_del(element); 786 list_del(element);
787 DEC_STAT(&priv->msg_free_stat); 787 DEC_STAT(&priv->msg_free_stat);
788 788
789 list_add_tail(element, &priv->msg_pend_list); 789 list_add_tail(element, &priv->msg_pend_list);
790 INC_STAT(&priv->msg_pend_stat); 790 INC_STAT(&priv->msg_pend_stat);
791 791
792 ipw2100_tx_send_commands(priv); 792 ipw2100_tx_send_commands(priv);
793 ipw2100_tx_send_data(priv); 793 ipw2100_tx_send_data(priv);
794 794
795 spin_unlock_irqrestore(&priv->low_lock, flags); 795 spin_unlock_irqrestore(&priv->low_lock, flags);
796 796
797 /* 797 /*
798 * We must wait for this command to complete before another 798 * We must wait for this command to complete before another
799 * command can be sent... but if we wait more than 3 seconds 799 * command can be sent... but if we wait more than 3 seconds
800 * then there is a problem. 800 * then there is a problem.
801 */ 801 */
802 802
803 err = 803 err =
804 wait_event_interruptible_timeout(priv->wait_command_queue, 804 wait_event_interruptible_timeout(priv->wait_command_queue,
805 !(priv-> 805 !(priv->
806 status & STATUS_CMD_ACTIVE), 806 status & STATUS_CMD_ACTIVE),
807 HOST_COMPLETE_TIMEOUT); 807 HOST_COMPLETE_TIMEOUT);
808 808
809 if (err == 0) { 809 if (err == 0) {
810 IPW_DEBUG_INFO("Command completion failed out after %dms.\n", 810 IPW_DEBUG_INFO("Command completion failed out after %dms.\n",
811 1000 * (HOST_COMPLETE_TIMEOUT / HZ)); 811 1000 * (HOST_COMPLETE_TIMEOUT / HZ));
812 priv->fatal_error = IPW2100_ERR_MSG_TIMEOUT; 812 priv->fatal_error = IPW2100_ERR_MSG_TIMEOUT;
813 priv->status &= ~STATUS_CMD_ACTIVE; 813 priv->status &= ~STATUS_CMD_ACTIVE;
814 schedule_reset(priv); 814 schedule_reset(priv);
815 return -EIO; 815 return -EIO;
816 } 816 }
817 817
818 if (priv->fatal_error) { 818 if (priv->fatal_error) {
819 printk(KERN_WARNING DRV_NAME ": %s: firmware fatal error\n", 819 printk(KERN_WARNING DRV_NAME ": %s: firmware fatal error\n",
820 priv->net_dev->name); 820 priv->net_dev->name);
821 return -EIO; 821 return -EIO;
822 } 822 }
823 823
824 /* !!!!! HACK TEST !!!!! 824 /* !!!!! HACK TEST !!!!!
825 * When lots of debug trace statements are enabled, the driver 825 * When lots of debug trace statements are enabled, the driver
826 * doesn't seem to have as many firmware restart cycles... 826 * doesn't seem to have as many firmware restart cycles...
827 * 827 *
828 * As a test, we're sticking in a 1/100s delay here */ 828 * As a test, we're sticking in a 1/100s delay here */
829 schedule_timeout_uninterruptible(msecs_to_jiffies(10)); 829 schedule_timeout_uninterruptible(msecs_to_jiffies(10));
830 830
831 return 0; 831 return 0;
832 832
833 fail_unlock: 833 fail_unlock:
834 spin_unlock_irqrestore(&priv->low_lock, flags); 834 spin_unlock_irqrestore(&priv->low_lock, flags);
835 835
836 return err; 836 return err;
837 } 837 }
838 838
839 /* 839 /*
840 * Verify the values and data access of the hardware 840 * Verify the values and data access of the hardware
841 * No locks needed or used. No functions called. 841 * No locks needed or used. No functions called.
842 */ 842 */
843 static int ipw2100_verify(struct ipw2100_priv *priv) 843 static int ipw2100_verify(struct ipw2100_priv *priv)
844 { 844 {
845 u32 data1, data2; 845 u32 data1, data2;
846 u32 address; 846 u32 address;
847 847
848 u32 val1 = 0x76543210; 848 u32 val1 = 0x76543210;
849 u32 val2 = 0xFEDCBA98; 849 u32 val2 = 0xFEDCBA98;
850 850
851 /* Domain 0 check - all values should be DOA_DEBUG */ 851 /* Domain 0 check - all values should be DOA_DEBUG */
852 for (address = IPW_REG_DOA_DEBUG_AREA_START; 852 for (address = IPW_REG_DOA_DEBUG_AREA_START;
853 address < IPW_REG_DOA_DEBUG_AREA_END; address += sizeof(u32)) { 853 address < IPW_REG_DOA_DEBUG_AREA_END; address += sizeof(u32)) {
854 read_register(priv->net_dev, address, &data1); 854 read_register(priv->net_dev, address, &data1);
855 if (data1 != IPW_DATA_DOA_DEBUG_VALUE) 855 if (data1 != IPW_DATA_DOA_DEBUG_VALUE)
856 return -EIO; 856 return -EIO;
857 } 857 }
858 858
859 /* Domain 1 check - use arbitrary read/write compare */ 859 /* Domain 1 check - use arbitrary read/write compare */
860 for (address = 0; address < 5; address++) { 860 for (address = 0; address < 5; address++) {
861 /* The memory area is not used now */ 861 /* The memory area is not used now */
862 write_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x32, 862 write_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x32,
863 val1); 863 val1);
864 write_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x36, 864 write_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x36,
865 val2); 865 val2);
866 read_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x32, 866 read_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x32,
867 &data1); 867 &data1);
868 read_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x36, 868 read_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x36,
869 &data2); 869 &data2);
870 if (val1 == data1 && val2 == data2) 870 if (val1 == data1 && val2 == data2)
871 return 0; 871 return 0;
872 } 872 }
873 873
874 return -EIO; 874 return -EIO;
875 } 875 }
876 876
877 /* 877 /*
878 * 878 *
879 * Loop until the CARD_DISABLED bit is the same value as the 879 * Loop until the CARD_DISABLED bit is the same value as the
880 * supplied parameter 880 * supplied parameter
881 * 881 *
882 * TODO: See if it would be more efficient to do a wait/wake 882 * TODO: See if it would be more efficient to do a wait/wake
883 * cycle and have the completion event trigger the wakeup 883 * cycle and have the completion event trigger the wakeup
884 * 884 *
885 */ 885 */
886 #define IPW_CARD_DISABLE_COMPLETE_WAIT 100 // 100 milli 886 #define IPW_CARD_DISABLE_COMPLETE_WAIT 100 // 100 milli
887 static int ipw2100_wait_for_card_state(struct ipw2100_priv *priv, int state) 887 static int ipw2100_wait_for_card_state(struct ipw2100_priv *priv, int state)
888 { 888 {
889 int i; 889 int i;
890 u32 card_state; 890 u32 card_state;
891 u32 len = sizeof(card_state); 891 u32 len = sizeof(card_state);
892 int err; 892 int err;
893 893
894 for (i = 0; i <= IPW_CARD_DISABLE_COMPLETE_WAIT * 1000; i += 50) { 894 for (i = 0; i <= IPW_CARD_DISABLE_COMPLETE_WAIT * 1000; i += 50) {
895 err = ipw2100_get_ordinal(priv, IPW_ORD_CARD_DISABLED, 895 err = ipw2100_get_ordinal(priv, IPW_ORD_CARD_DISABLED,
896 &card_state, &len); 896 &card_state, &len);
897 if (err) { 897 if (err) {
898 IPW_DEBUG_INFO("Query of CARD_DISABLED ordinal " 898 IPW_DEBUG_INFO("Query of CARD_DISABLED ordinal "
899 "failed.\n"); 899 "failed.\n");
900 return 0; 900 return 0;
901 } 901 }
902 902
903 /* We'll break out if either the HW state says it is 903 /* We'll break out if either the HW state says it is
904 * in the state we want, or if HOST_COMPLETE command 904 * in the state we want, or if HOST_COMPLETE command
905 * finishes */ 905 * finishes */
906 if ((card_state == state) || 906 if ((card_state == state) ||
907 ((priv->status & STATUS_ENABLED) ? 907 ((priv->status & STATUS_ENABLED) ?
908 IPW_HW_STATE_ENABLED : IPW_HW_STATE_DISABLED) == state) { 908 IPW_HW_STATE_ENABLED : IPW_HW_STATE_DISABLED) == state) {
909 if (state == IPW_HW_STATE_ENABLED) 909 if (state == IPW_HW_STATE_ENABLED)
910 priv->status |= STATUS_ENABLED; 910 priv->status |= STATUS_ENABLED;
911 else 911 else
912 priv->status &= ~STATUS_ENABLED; 912 priv->status &= ~STATUS_ENABLED;
913 913
914 return 0; 914 return 0;
915 } 915 }
916 916
917 udelay(50); 917 udelay(50);
918 } 918 }
919 919
920 IPW_DEBUG_INFO("ipw2100_wait_for_card_state to %s state timed out\n", 920 IPW_DEBUG_INFO("ipw2100_wait_for_card_state to %s state timed out\n",
921 state ? "DISABLED" : "ENABLED"); 921 state ? "DISABLED" : "ENABLED");
922 return -EIO; 922 return -EIO;
923 } 923 }
924 924
925 /********************************************************************* 925 /*********************************************************************
926 Procedure : sw_reset_and_clock 926 Procedure : sw_reset_and_clock
927 Purpose : Asserts s/w reset, asserts clock initialization 927 Purpose : Asserts s/w reset, asserts clock initialization
928 and waits for clock stabilization 928 and waits for clock stabilization
929 ********************************************************************/ 929 ********************************************************************/
930 static int sw_reset_and_clock(struct ipw2100_priv *priv) 930 static int sw_reset_and_clock(struct ipw2100_priv *priv)
931 { 931 {
932 int i; 932 int i;
933 u32 r; 933 u32 r;
934 934
935 // assert s/w reset 935 // assert s/w reset
936 write_register(priv->net_dev, IPW_REG_RESET_REG, 936 write_register(priv->net_dev, IPW_REG_RESET_REG,
937 IPW_AUX_HOST_RESET_REG_SW_RESET); 937 IPW_AUX_HOST_RESET_REG_SW_RESET);
938 938
939 // wait for clock stabilization 939 // wait for clock stabilization
940 for (i = 0; i < 1000; i++) { 940 for (i = 0; i < 1000; i++) {
941 udelay(IPW_WAIT_RESET_ARC_COMPLETE_DELAY); 941 udelay(IPW_WAIT_RESET_ARC_COMPLETE_DELAY);
942 942
943 // check clock ready bit 943 // check clock ready bit
944 read_register(priv->net_dev, IPW_REG_RESET_REG, &r); 944 read_register(priv->net_dev, IPW_REG_RESET_REG, &r);
945 if (r & IPW_AUX_HOST_RESET_REG_PRINCETON_RESET) 945 if (r & IPW_AUX_HOST_RESET_REG_PRINCETON_RESET)
946 break; 946 break;
947 } 947 }
948 948
949 if (i == 1000) 949 if (i == 1000)
950 return -EIO; // TODO: better error value 950 return -EIO; // TODO: better error value
951 951
952 /* set "initialization complete" bit to move adapter to 952 /* set "initialization complete" bit to move adapter to
953 * D0 state */ 953 * D0 state */
954 write_register(priv->net_dev, IPW_REG_GP_CNTRL, 954 write_register(priv->net_dev, IPW_REG_GP_CNTRL,
955 IPW_AUX_HOST_GP_CNTRL_BIT_INIT_DONE); 955 IPW_AUX_HOST_GP_CNTRL_BIT_INIT_DONE);
956 956
957 /* wait for clock stabilization */ 957 /* wait for clock stabilization */
958 for (i = 0; i < 10000; i++) { 958 for (i = 0; i < 10000; i++) {
959 udelay(IPW_WAIT_CLOCK_STABILIZATION_DELAY * 4); 959 udelay(IPW_WAIT_CLOCK_STABILIZATION_DELAY * 4);
960 960
961 /* check clock ready bit */ 961 /* check clock ready bit */
962 read_register(priv->net_dev, IPW_REG_GP_CNTRL, &r); 962 read_register(priv->net_dev, IPW_REG_GP_CNTRL, &r);
963 if (r & IPW_AUX_HOST_GP_CNTRL_BIT_CLOCK_READY) 963 if (r & IPW_AUX_HOST_GP_CNTRL_BIT_CLOCK_READY)
964 break; 964 break;
965 } 965 }
966 966
967 if (i == 10000) 967 if (i == 10000)
968 return -EIO; /* TODO: better error value */ 968 return -EIO; /* TODO: better error value */
969 969
970 /* set D0 standby bit */ 970 /* set D0 standby bit */
971 read_register(priv->net_dev, IPW_REG_GP_CNTRL, &r); 971 read_register(priv->net_dev, IPW_REG_GP_CNTRL, &r);
972 write_register(priv->net_dev, IPW_REG_GP_CNTRL, 972 write_register(priv->net_dev, IPW_REG_GP_CNTRL,
973 r | IPW_AUX_HOST_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY); 973 r | IPW_AUX_HOST_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
974 974
975 return 0; 975 return 0;
976 } 976 }
977 977
978 /********************************************************************* 978 /*********************************************************************
979 Procedure : ipw2100_download_firmware 979 Procedure : ipw2100_download_firmware
980 Purpose : Initiaze adapter after power on. 980 Purpose : Initiaze adapter after power on.
981 The sequence is: 981 The sequence is:
982 1. assert s/w reset first! 982 1. assert s/w reset first!
983 2. awake clocks & wait for clock stabilization 983 2. awake clocks & wait for clock stabilization
984 3. hold ARC (don't ask me why...) 984 3. hold ARC (don't ask me why...)
985 4. load Dino ucode and reset/clock init again 985 4. load Dino ucode and reset/clock init again
986 5. zero-out shared mem 986 5. zero-out shared mem
987 6. download f/w 987 6. download f/w
988 *******************************************************************/ 988 *******************************************************************/
989 static int ipw2100_download_firmware(struct ipw2100_priv *priv) 989 static int ipw2100_download_firmware(struct ipw2100_priv *priv)
990 { 990 {
991 u32 address; 991 u32 address;
992 int err; 992 int err;
993 993
994 #ifndef CONFIG_PM 994 #ifndef CONFIG_PM
995 /* Fetch the firmware and microcode */ 995 /* Fetch the firmware and microcode */
996 struct ipw2100_fw ipw2100_firmware; 996 struct ipw2100_fw ipw2100_firmware;
997 #endif 997 #endif
998 998
999 if (priv->fatal_error) { 999 if (priv->fatal_error) {
1000 IPW_DEBUG_ERROR("%s: ipw2100_download_firmware called after " 1000 IPW_DEBUG_ERROR("%s: ipw2100_download_firmware called after "
1001 "fatal error %d. Interface must be brought down.\n", 1001 "fatal error %d. Interface must be brought down.\n",
1002 priv->net_dev->name, priv->fatal_error); 1002 priv->net_dev->name, priv->fatal_error);
1003 return -EINVAL; 1003 return -EINVAL;
1004 } 1004 }
1005 #ifdef CONFIG_PM 1005 #ifdef CONFIG_PM
1006 if (!ipw2100_firmware.version) { 1006 if (!ipw2100_firmware.version) {
1007 err = ipw2100_get_firmware(priv, &ipw2100_firmware); 1007 err = ipw2100_get_firmware(priv, &ipw2100_firmware);
1008 if (err) { 1008 if (err) {
1009 IPW_DEBUG_ERROR("%s: ipw2100_get_firmware failed: %d\n", 1009 IPW_DEBUG_ERROR("%s: ipw2100_get_firmware failed: %d\n",
1010 priv->net_dev->name, err); 1010 priv->net_dev->name, err);
1011 priv->fatal_error = IPW2100_ERR_FW_LOAD; 1011 priv->fatal_error = IPW2100_ERR_FW_LOAD;
1012 goto fail; 1012 goto fail;
1013 } 1013 }
1014 } 1014 }
1015 #else 1015 #else
1016 err = ipw2100_get_firmware(priv, &ipw2100_firmware); 1016 err = ipw2100_get_firmware(priv, &ipw2100_firmware);
1017 if (err) { 1017 if (err) {
1018 IPW_DEBUG_ERROR("%s: ipw2100_get_firmware failed: %d\n", 1018 IPW_DEBUG_ERROR("%s: ipw2100_get_firmware failed: %d\n",
1019 priv->net_dev->name, err); 1019 priv->net_dev->name, err);
1020 priv->fatal_error = IPW2100_ERR_FW_LOAD; 1020 priv->fatal_error = IPW2100_ERR_FW_LOAD;
1021 goto fail; 1021 goto fail;
1022 } 1022 }
1023 #endif 1023 #endif
1024 priv->firmware_version = ipw2100_firmware.version; 1024 priv->firmware_version = ipw2100_firmware.version;
1025 1025
1026 /* s/w reset and clock stabilization */ 1026 /* s/w reset and clock stabilization */
1027 err = sw_reset_and_clock(priv); 1027 err = sw_reset_and_clock(priv);
1028 if (err) { 1028 if (err) {
1029 IPW_DEBUG_ERROR("%s: sw_reset_and_clock failed: %d\n", 1029 IPW_DEBUG_ERROR("%s: sw_reset_and_clock failed: %d\n",
1030 priv->net_dev->name, err); 1030 priv->net_dev->name, err);
1031 goto fail; 1031 goto fail;
1032 } 1032 }
1033 1033
1034 err = ipw2100_verify(priv); 1034 err = ipw2100_verify(priv);
1035 if (err) { 1035 if (err) {
1036 IPW_DEBUG_ERROR("%s: ipw2100_verify failed: %d\n", 1036 IPW_DEBUG_ERROR("%s: ipw2100_verify failed: %d\n",
1037 priv->net_dev->name, err); 1037 priv->net_dev->name, err);
1038 goto fail; 1038 goto fail;
1039 } 1039 }
1040 1040
1041 /* Hold ARC */ 1041 /* Hold ARC */
1042 write_nic_dword(priv->net_dev, 1042 write_nic_dword(priv->net_dev,
1043 IPW_INTERNAL_REGISTER_HALT_AND_RESET, 0x80000000); 1043 IPW_INTERNAL_REGISTER_HALT_AND_RESET, 0x80000000);
1044 1044
1045 /* allow ARC to run */ 1045 /* allow ARC to run */
1046 write_register(priv->net_dev, IPW_REG_RESET_REG, 0); 1046 write_register(priv->net_dev, IPW_REG_RESET_REG, 0);
1047 1047
1048 /* load microcode */ 1048 /* load microcode */
1049 err = ipw2100_ucode_download(priv, &ipw2100_firmware); 1049 err = ipw2100_ucode_download(priv, &ipw2100_firmware);
1050 if (err) { 1050 if (err) {
1051 printk(KERN_ERR DRV_NAME ": %s: Error loading microcode: %d\n", 1051 printk(KERN_ERR DRV_NAME ": %s: Error loading microcode: %d\n",
1052 priv->net_dev->name, err); 1052 priv->net_dev->name, err);
1053 goto fail; 1053 goto fail;
1054 } 1054 }
1055 1055
1056 /* release ARC */ 1056 /* release ARC */
1057 write_nic_dword(priv->net_dev, 1057 write_nic_dword(priv->net_dev,
1058 IPW_INTERNAL_REGISTER_HALT_AND_RESET, 0x00000000); 1058 IPW_INTERNAL_REGISTER_HALT_AND_RESET, 0x00000000);
1059 1059
1060 /* s/w reset and clock stabilization (again!!!) */ 1060 /* s/w reset and clock stabilization (again!!!) */
1061 err = sw_reset_and_clock(priv); 1061 err = sw_reset_and_clock(priv);
1062 if (err) { 1062 if (err) {
1063 printk(KERN_ERR DRV_NAME 1063 printk(KERN_ERR DRV_NAME
1064 ": %s: sw_reset_and_clock failed: %d\n", 1064 ": %s: sw_reset_and_clock failed: %d\n",
1065 priv->net_dev->name, err); 1065 priv->net_dev->name, err);
1066 goto fail; 1066 goto fail;
1067 } 1067 }
1068 1068
1069 /* load f/w */ 1069 /* load f/w */
1070 err = ipw2100_fw_download(priv, &ipw2100_firmware); 1070 err = ipw2100_fw_download(priv, &ipw2100_firmware);
1071 if (err) { 1071 if (err) {
1072 IPW_DEBUG_ERROR("%s: Error loading firmware: %d\n", 1072 IPW_DEBUG_ERROR("%s: Error loading firmware: %d\n",
1073 priv->net_dev->name, err); 1073 priv->net_dev->name, err);
1074 goto fail; 1074 goto fail;
1075 } 1075 }
1076 #ifndef CONFIG_PM 1076 #ifndef CONFIG_PM
1077 /* 1077 /*
1078 * When the .resume method of the driver is called, the other 1078 * When the .resume method of the driver is called, the other
1079 * part of the system, i.e. the ide driver could still stay in 1079 * part of the system, i.e. the ide driver could still stay in
1080 * the suspend stage. This prevents us from loading the firmware 1080 * the suspend stage. This prevents us from loading the firmware
1081 * from the disk. --YZ 1081 * from the disk. --YZ
1082 */ 1082 */
1083 1083
1084 /* free any storage allocated for firmware image */ 1084 /* free any storage allocated for firmware image */
1085 ipw2100_release_firmware(priv, &ipw2100_firmware); 1085 ipw2100_release_firmware(priv, &ipw2100_firmware);
1086 #endif 1086 #endif
1087 1087
1088 /* zero out Domain 1 area indirectly (Si requirement) */ 1088 /* zero out Domain 1 area indirectly (Si requirement) */
1089 for (address = IPW_HOST_FW_SHARED_AREA0; 1089 for (address = IPW_HOST_FW_SHARED_AREA0;
1090 address < IPW_HOST_FW_SHARED_AREA0_END; address += 4) 1090 address < IPW_HOST_FW_SHARED_AREA0_END; address += 4)
1091 write_nic_dword(priv->net_dev, address, 0); 1091 write_nic_dword(priv->net_dev, address, 0);
1092 for (address = IPW_HOST_FW_SHARED_AREA1; 1092 for (address = IPW_HOST_FW_SHARED_AREA1;
1093 address < IPW_HOST_FW_SHARED_AREA1_END; address += 4) 1093 address < IPW_HOST_FW_SHARED_AREA1_END; address += 4)
1094 write_nic_dword(priv->net_dev, address, 0); 1094 write_nic_dword(priv->net_dev, address, 0);
1095 for (address = IPW_HOST_FW_SHARED_AREA2; 1095 for (address = IPW_HOST_FW_SHARED_AREA2;
1096 address < IPW_HOST_FW_SHARED_AREA2_END; address += 4) 1096 address < IPW_HOST_FW_SHARED_AREA2_END; address += 4)
1097 write_nic_dword(priv->net_dev, address, 0); 1097 write_nic_dword(priv->net_dev, address, 0);
1098 for (address = IPW_HOST_FW_SHARED_AREA3; 1098 for (address = IPW_HOST_FW_SHARED_AREA3;
1099 address < IPW_HOST_FW_SHARED_AREA3_END; address += 4) 1099 address < IPW_HOST_FW_SHARED_AREA3_END; address += 4)
1100 write_nic_dword(priv->net_dev, address, 0); 1100 write_nic_dword(priv->net_dev, address, 0);
1101 for (address = IPW_HOST_FW_INTERRUPT_AREA; 1101 for (address = IPW_HOST_FW_INTERRUPT_AREA;
1102 address < IPW_HOST_FW_INTERRUPT_AREA_END; address += 4) 1102 address < IPW_HOST_FW_INTERRUPT_AREA_END; address += 4)
1103 write_nic_dword(priv->net_dev, address, 0); 1103 write_nic_dword(priv->net_dev, address, 0);
1104 1104
1105 return 0; 1105 return 0;
1106 1106
1107 fail: 1107 fail:
1108 ipw2100_release_firmware(priv, &ipw2100_firmware); 1108 ipw2100_release_firmware(priv, &ipw2100_firmware);
1109 return err; 1109 return err;
1110 } 1110 }
1111 1111
1112 static inline void ipw2100_enable_interrupts(struct ipw2100_priv *priv) 1112 static inline void ipw2100_enable_interrupts(struct ipw2100_priv *priv)
1113 { 1113 {
1114 if (priv->status & STATUS_INT_ENABLED) 1114 if (priv->status & STATUS_INT_ENABLED)
1115 return; 1115 return;
1116 priv->status |= STATUS_INT_ENABLED; 1116 priv->status |= STATUS_INT_ENABLED;
1117 write_register(priv->net_dev, IPW_REG_INTA_MASK, IPW_INTERRUPT_MASK); 1117 write_register(priv->net_dev, IPW_REG_INTA_MASK, IPW_INTERRUPT_MASK);
1118 } 1118 }
1119 1119
1120 static inline void ipw2100_disable_interrupts(struct ipw2100_priv *priv) 1120 static inline void ipw2100_disable_interrupts(struct ipw2100_priv *priv)
1121 { 1121 {
1122 if (!(priv->status & STATUS_INT_ENABLED)) 1122 if (!(priv->status & STATUS_INT_ENABLED))
1123 return; 1123 return;
1124 priv->status &= ~STATUS_INT_ENABLED; 1124 priv->status &= ~STATUS_INT_ENABLED;
1125 write_register(priv->net_dev, IPW_REG_INTA_MASK, 0x0); 1125 write_register(priv->net_dev, IPW_REG_INTA_MASK, 0x0);
1126 } 1126 }
1127 1127
1128 static void ipw2100_initialize_ordinals(struct ipw2100_priv *priv) 1128 static void ipw2100_initialize_ordinals(struct ipw2100_priv *priv)
1129 { 1129 {
1130 struct ipw2100_ordinals *ord = &priv->ordinals; 1130 struct ipw2100_ordinals *ord = &priv->ordinals;
1131 1131
1132 IPW_DEBUG_INFO("enter\n"); 1132 IPW_DEBUG_INFO("enter\n");
1133 1133
1134 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_ORDINALS_TABLE_1, 1134 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_ORDINALS_TABLE_1,
1135 &ord->table1_addr); 1135 &ord->table1_addr);
1136 1136
1137 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_ORDINALS_TABLE_2, 1137 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_ORDINALS_TABLE_2,
1138 &ord->table2_addr); 1138 &ord->table2_addr);
1139 1139
1140 read_nic_dword(priv->net_dev, ord->table1_addr, &ord->table1_size); 1140 read_nic_dword(priv->net_dev, ord->table1_addr, &ord->table1_size);
1141 read_nic_dword(priv->net_dev, ord->table2_addr, &ord->table2_size); 1141 read_nic_dword(priv->net_dev, ord->table2_addr, &ord->table2_size);
1142 1142
1143 ord->table2_size &= 0x0000FFFF; 1143 ord->table2_size &= 0x0000FFFF;
1144 1144
1145 IPW_DEBUG_INFO("table 1 size: %d\n", ord->table1_size); 1145 IPW_DEBUG_INFO("table 1 size: %d\n", ord->table1_size);
1146 IPW_DEBUG_INFO("table 2 size: %d\n", ord->table2_size); 1146 IPW_DEBUG_INFO("table 2 size: %d\n", ord->table2_size);
1147 IPW_DEBUG_INFO("exit\n"); 1147 IPW_DEBUG_INFO("exit\n");
1148 } 1148 }
1149 1149
1150 static inline void ipw2100_hw_set_gpio(struct ipw2100_priv *priv) 1150 static inline void ipw2100_hw_set_gpio(struct ipw2100_priv *priv)
1151 { 1151 {
1152 u32 reg = 0; 1152 u32 reg = 0;
1153 /* 1153 /*
1154 * Set GPIO 3 writable by FW; GPIO 1 writable 1154 * Set GPIO 3 writable by FW; GPIO 1 writable
1155 * by driver and enable clock 1155 * by driver and enable clock
1156 */ 1156 */
1157 reg = (IPW_BIT_GPIO_GPIO3_MASK | IPW_BIT_GPIO_GPIO1_ENABLE | 1157 reg = (IPW_BIT_GPIO_GPIO3_MASK | IPW_BIT_GPIO_GPIO1_ENABLE |
1158 IPW_BIT_GPIO_LED_OFF); 1158 IPW_BIT_GPIO_LED_OFF);
1159 write_register(priv->net_dev, IPW_REG_GPIO, reg); 1159 write_register(priv->net_dev, IPW_REG_GPIO, reg);
1160 } 1160 }
1161 1161
1162 static int rf_kill_active(struct ipw2100_priv *priv) 1162 static int rf_kill_active(struct ipw2100_priv *priv)
1163 { 1163 {
1164 #define MAX_RF_KILL_CHECKS 5 1164 #define MAX_RF_KILL_CHECKS 5
1165 #define RF_KILL_CHECK_DELAY 40 1165 #define RF_KILL_CHECK_DELAY 40
1166 1166
1167 unsigned short value = 0; 1167 unsigned short value = 0;
1168 u32 reg = 0; 1168 u32 reg = 0;
1169 int i; 1169 int i;
1170 1170
1171 if (!(priv->hw_features & HW_FEATURE_RFKILL)) { 1171 if (!(priv->hw_features & HW_FEATURE_RFKILL)) {
1172 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, false); 1172 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, false);
1173 priv->status &= ~STATUS_RF_KILL_HW; 1173 priv->status &= ~STATUS_RF_KILL_HW;
1174 return 0; 1174 return 0;
1175 } 1175 }
1176 1176
1177 for (i = 0; i < MAX_RF_KILL_CHECKS; i++) { 1177 for (i = 0; i < MAX_RF_KILL_CHECKS; i++) {
1178 udelay(RF_KILL_CHECK_DELAY); 1178 udelay(RF_KILL_CHECK_DELAY);
1179 read_register(priv->net_dev, IPW_REG_GPIO, &reg); 1179 read_register(priv->net_dev, IPW_REG_GPIO, &reg);
1180 value = (value << 1) | ((reg & IPW_BIT_GPIO_RF_KILL) ? 0 : 1); 1180 value = (value << 1) | ((reg & IPW_BIT_GPIO_RF_KILL) ? 0 : 1);
1181 } 1181 }
1182 1182
1183 if (value == 0) { 1183 if (value == 0) {
1184 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true); 1184 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true);
1185 priv->status |= STATUS_RF_KILL_HW; 1185 priv->status |= STATUS_RF_KILL_HW;
1186 } else { 1186 } else {
1187 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, false); 1187 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, false);
1188 priv->status &= ~STATUS_RF_KILL_HW; 1188 priv->status &= ~STATUS_RF_KILL_HW;
1189 } 1189 }
1190 1190
1191 return (value == 0); 1191 return (value == 0);
1192 } 1192 }
1193 1193
1194 static int ipw2100_get_hw_features(struct ipw2100_priv *priv) 1194 static int ipw2100_get_hw_features(struct ipw2100_priv *priv)
1195 { 1195 {
1196 u32 addr, len; 1196 u32 addr, len;
1197 u32 val; 1197 u32 val;
1198 1198
1199 /* 1199 /*
1200 * EEPROM_SRAM_DB_START_ADDRESS using ordinal in ordinal table 1 1200 * EEPROM_SRAM_DB_START_ADDRESS using ordinal in ordinal table 1
1201 */ 1201 */
1202 len = sizeof(addr); 1202 len = sizeof(addr);
1203 if (ipw2100_get_ordinal 1203 if (ipw2100_get_ordinal
1204 (priv, IPW_ORD_EEPROM_SRAM_DB_BLOCK_START_ADDRESS, &addr, &len)) { 1204 (priv, IPW_ORD_EEPROM_SRAM_DB_BLOCK_START_ADDRESS, &addr, &len)) {
1205 IPW_DEBUG_INFO("failed querying ordinals at line %d\n", 1205 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
1206 __LINE__); 1206 __LINE__);
1207 return -EIO; 1207 return -EIO;
1208 } 1208 }
1209 1209
1210 IPW_DEBUG_INFO("EEPROM address: %08X\n", addr); 1210 IPW_DEBUG_INFO("EEPROM address: %08X\n", addr);
1211 1211
1212 /* 1212 /*
1213 * EEPROM version is the byte at offset 0xfd in firmware 1213 * EEPROM version is the byte at offset 0xfd in firmware
1214 * We read 4 bytes, then shift out the byte we actually want */ 1214 * We read 4 bytes, then shift out the byte we actually want */
1215 read_nic_dword(priv->net_dev, addr + 0xFC, &val); 1215 read_nic_dword(priv->net_dev, addr + 0xFC, &val);
1216 priv->eeprom_version = (val >> 24) & 0xFF; 1216 priv->eeprom_version = (val >> 24) & 0xFF;
1217 IPW_DEBUG_INFO("EEPROM version: %d\n", priv->eeprom_version); 1217 IPW_DEBUG_INFO("EEPROM version: %d\n", priv->eeprom_version);
1218 1218
1219 /* 1219 /*
1220 * HW RF Kill enable is bit 0 in byte at offset 0x21 in firmware 1220 * HW RF Kill enable is bit 0 in byte at offset 0x21 in firmware
1221 * 1221 *
1222 * notice that the EEPROM bit is reverse polarity, i.e. 1222 * notice that the EEPROM bit is reverse polarity, i.e.
1223 * bit = 0 signifies HW RF kill switch is supported 1223 * bit = 0 signifies HW RF kill switch is supported
1224 * bit = 1 signifies HW RF kill switch is NOT supported 1224 * bit = 1 signifies HW RF kill switch is NOT supported
1225 */ 1225 */
1226 read_nic_dword(priv->net_dev, addr + 0x20, &val); 1226 read_nic_dword(priv->net_dev, addr + 0x20, &val);
1227 if (!((val >> 24) & 0x01)) 1227 if (!((val >> 24) & 0x01))
1228 priv->hw_features |= HW_FEATURE_RFKILL; 1228 priv->hw_features |= HW_FEATURE_RFKILL;
1229 1229
1230 IPW_DEBUG_INFO("HW RF Kill: %ssupported.\n", 1230 IPW_DEBUG_INFO("HW RF Kill: %ssupported.\n",
1231 (priv->hw_features & HW_FEATURE_RFKILL) ? "" : "not "); 1231 (priv->hw_features & HW_FEATURE_RFKILL) ? "" : "not ");
1232 1232
1233 return 0; 1233 return 0;
1234 } 1234 }
1235 1235
1236 /* 1236 /*
1237 * Start firmware execution after power on and intialization 1237 * Start firmware execution after power on and intialization
1238 * The sequence is: 1238 * The sequence is:
1239 * 1. Release ARC 1239 * 1. Release ARC
1240 * 2. Wait for f/w initialization completes; 1240 * 2. Wait for f/w initialization completes;
1241 */ 1241 */
1242 static int ipw2100_start_adapter(struct ipw2100_priv *priv) 1242 static int ipw2100_start_adapter(struct ipw2100_priv *priv)
1243 { 1243 {
1244 int i; 1244 int i;
1245 u32 inta, inta_mask, gpio; 1245 u32 inta, inta_mask, gpio;
1246 1246
1247 IPW_DEBUG_INFO("enter\n"); 1247 IPW_DEBUG_INFO("enter\n");
1248 1248
1249 if (priv->status & STATUS_RUNNING) 1249 if (priv->status & STATUS_RUNNING)
1250 return 0; 1250 return 0;
1251 1251
1252 /* 1252 /*
1253 * Initialize the hw - drive adapter to DO state by setting 1253 * Initialize the hw - drive adapter to DO state by setting
1254 * init_done bit. Wait for clk_ready bit and Download 1254 * init_done bit. Wait for clk_ready bit and Download
1255 * fw & dino ucode 1255 * fw & dino ucode
1256 */ 1256 */
1257 if (ipw2100_download_firmware(priv)) { 1257 if (ipw2100_download_firmware(priv)) {
1258 printk(KERN_ERR DRV_NAME 1258 printk(KERN_ERR DRV_NAME
1259 ": %s: Failed to power on the adapter.\n", 1259 ": %s: Failed to power on the adapter.\n",
1260 priv->net_dev->name); 1260 priv->net_dev->name);
1261 return -EIO; 1261 return -EIO;
1262 } 1262 }
1263 1263
1264 /* Clear the Tx, Rx and Msg queues and the r/w indexes 1264 /* Clear the Tx, Rx and Msg queues and the r/w indexes
1265 * in the firmware RBD and TBD ring queue */ 1265 * in the firmware RBD and TBD ring queue */
1266 ipw2100_queues_initialize(priv); 1266 ipw2100_queues_initialize(priv);
1267 1267
1268 ipw2100_hw_set_gpio(priv); 1268 ipw2100_hw_set_gpio(priv);
1269 1269
1270 /* TODO -- Look at disabling interrupts here to make sure none 1270 /* TODO -- Look at disabling interrupts here to make sure none
1271 * get fired during FW initialization */ 1271 * get fired during FW initialization */
1272 1272
1273 /* Release ARC - clear reset bit */ 1273 /* Release ARC - clear reset bit */
1274 write_register(priv->net_dev, IPW_REG_RESET_REG, 0); 1274 write_register(priv->net_dev, IPW_REG_RESET_REG, 0);
1275 1275
1276 /* wait for f/w intialization complete */ 1276 /* wait for f/w intialization complete */
1277 IPW_DEBUG_FW("Waiting for f/w initialization to complete...\n"); 1277 IPW_DEBUG_FW("Waiting for f/w initialization to complete...\n");
1278 i = 5000; 1278 i = 5000;
1279 do { 1279 do {
1280 schedule_timeout_uninterruptible(msecs_to_jiffies(40)); 1280 schedule_timeout_uninterruptible(msecs_to_jiffies(40));
1281 /* Todo... wait for sync command ... */ 1281 /* Todo... wait for sync command ... */
1282 1282
1283 read_register(priv->net_dev, IPW_REG_INTA, &inta); 1283 read_register(priv->net_dev, IPW_REG_INTA, &inta);
1284 1284
1285 /* check "init done" bit */ 1285 /* check "init done" bit */
1286 if (inta & IPW2100_INTA_FW_INIT_DONE) { 1286 if (inta & IPW2100_INTA_FW_INIT_DONE) {
1287 /* reset "init done" bit */ 1287 /* reset "init done" bit */
1288 write_register(priv->net_dev, IPW_REG_INTA, 1288 write_register(priv->net_dev, IPW_REG_INTA,
1289 IPW2100_INTA_FW_INIT_DONE); 1289 IPW2100_INTA_FW_INIT_DONE);
1290 break; 1290 break;
1291 } 1291 }
1292 1292
1293 /* check error conditions : we check these after the firmware 1293 /* check error conditions : we check these after the firmware
1294 * check so that if there is an error, the interrupt handler 1294 * check so that if there is an error, the interrupt handler
1295 * will see it and the adapter will be reset */ 1295 * will see it and the adapter will be reset */
1296 if (inta & 1296 if (inta &
1297 (IPW2100_INTA_FATAL_ERROR | IPW2100_INTA_PARITY_ERROR)) { 1297 (IPW2100_INTA_FATAL_ERROR | IPW2100_INTA_PARITY_ERROR)) {
1298 /* clear error conditions */ 1298 /* clear error conditions */
1299 write_register(priv->net_dev, IPW_REG_INTA, 1299 write_register(priv->net_dev, IPW_REG_INTA,
1300 IPW2100_INTA_FATAL_ERROR | 1300 IPW2100_INTA_FATAL_ERROR |
1301 IPW2100_INTA_PARITY_ERROR); 1301 IPW2100_INTA_PARITY_ERROR);
1302 } 1302 }
1303 } while (--i); 1303 } while (--i);
1304 1304
1305 /* Clear out any pending INTAs since we aren't supposed to have 1305 /* Clear out any pending INTAs since we aren't supposed to have
1306 * interrupts enabled at this point... */ 1306 * interrupts enabled at this point... */
1307 read_register(priv->net_dev, IPW_REG_INTA, &inta); 1307 read_register(priv->net_dev, IPW_REG_INTA, &inta);
1308 read_register(priv->net_dev, IPW_REG_INTA_MASK, &inta_mask); 1308 read_register(priv->net_dev, IPW_REG_INTA_MASK, &inta_mask);
1309 inta &= IPW_INTERRUPT_MASK; 1309 inta &= IPW_INTERRUPT_MASK;
1310 /* Clear out any pending interrupts */ 1310 /* Clear out any pending interrupts */
1311 if (inta & inta_mask) 1311 if (inta & inta_mask)
1312 write_register(priv->net_dev, IPW_REG_INTA, inta); 1312 write_register(priv->net_dev, IPW_REG_INTA, inta);
1313 1313
1314 IPW_DEBUG_FW("f/w initialization complete: %s\n", 1314 IPW_DEBUG_FW("f/w initialization complete: %s\n",
1315 i ? "SUCCESS" : "FAILED"); 1315 i ? "SUCCESS" : "FAILED");
1316 1316
1317 if (!i) { 1317 if (!i) {
1318 printk(KERN_WARNING DRV_NAME 1318 printk(KERN_WARNING DRV_NAME
1319 ": %s: Firmware did not initialize.\n", 1319 ": %s: Firmware did not initialize.\n",
1320 priv->net_dev->name); 1320 priv->net_dev->name);
1321 return -EIO; 1321 return -EIO;
1322 } 1322 }
1323 1323
1324 /* allow firmware to write to GPIO1 & GPIO3 */ 1324 /* allow firmware to write to GPIO1 & GPIO3 */
1325 read_register(priv->net_dev, IPW_REG_GPIO, &gpio); 1325 read_register(priv->net_dev, IPW_REG_GPIO, &gpio);
1326 1326
1327 gpio |= (IPW_BIT_GPIO_GPIO1_MASK | IPW_BIT_GPIO_GPIO3_MASK); 1327 gpio |= (IPW_BIT_GPIO_GPIO1_MASK | IPW_BIT_GPIO_GPIO3_MASK);
1328 1328
1329 write_register(priv->net_dev, IPW_REG_GPIO, gpio); 1329 write_register(priv->net_dev, IPW_REG_GPIO, gpio);
1330 1330
1331 /* Ready to receive commands */ 1331 /* Ready to receive commands */
1332 priv->status |= STATUS_RUNNING; 1332 priv->status |= STATUS_RUNNING;
1333 1333
1334 /* The adapter has been reset; we are not associated */ 1334 /* The adapter has been reset; we are not associated */
1335 priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED); 1335 priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
1336 1336
1337 IPW_DEBUG_INFO("exit\n"); 1337 IPW_DEBUG_INFO("exit\n");
1338 1338
1339 return 0; 1339 return 0;
1340 } 1340 }
1341 1341
1342 static inline void ipw2100_reset_fatalerror(struct ipw2100_priv *priv) 1342 static inline void ipw2100_reset_fatalerror(struct ipw2100_priv *priv)
1343 { 1343 {
1344 if (!priv->fatal_error) 1344 if (!priv->fatal_error)
1345 return; 1345 return;
1346 1346
1347 priv->fatal_errors[priv->fatal_index++] = priv->fatal_error; 1347 priv->fatal_errors[priv->fatal_index++] = priv->fatal_error;
1348 priv->fatal_index %= IPW2100_ERROR_QUEUE; 1348 priv->fatal_index %= IPW2100_ERROR_QUEUE;
1349 priv->fatal_error = 0; 1349 priv->fatal_error = 0;
1350 } 1350 }
1351 1351
1352 /* NOTE: Our interrupt is disabled when this method is called */ 1352 /* NOTE: Our interrupt is disabled when this method is called */
1353 static int ipw2100_power_cycle_adapter(struct ipw2100_priv *priv) 1353 static int ipw2100_power_cycle_adapter(struct ipw2100_priv *priv)
1354 { 1354 {
1355 u32 reg; 1355 u32 reg;
1356 int i; 1356 int i;
1357 1357
1358 IPW_DEBUG_INFO("Power cycling the hardware.\n"); 1358 IPW_DEBUG_INFO("Power cycling the hardware.\n");
1359 1359
1360 ipw2100_hw_set_gpio(priv); 1360 ipw2100_hw_set_gpio(priv);
1361 1361
1362 /* Step 1. Stop Master Assert */ 1362 /* Step 1. Stop Master Assert */
1363 write_register(priv->net_dev, IPW_REG_RESET_REG, 1363 write_register(priv->net_dev, IPW_REG_RESET_REG,
1364 IPW_AUX_HOST_RESET_REG_STOP_MASTER); 1364 IPW_AUX_HOST_RESET_REG_STOP_MASTER);
1365 1365
1366 /* Step 2. Wait for stop Master Assert 1366 /* Step 2. Wait for stop Master Assert
1367 * (not more than 50us, otherwise ret error */ 1367 * (not more than 50us, otherwise ret error */
1368 i = 5; 1368 i = 5;
1369 do { 1369 do {
1370 udelay(IPW_WAIT_RESET_MASTER_ASSERT_COMPLETE_DELAY); 1370 udelay(IPW_WAIT_RESET_MASTER_ASSERT_COMPLETE_DELAY);
1371 read_register(priv->net_dev, IPW_REG_RESET_REG, &reg); 1371 read_register(priv->net_dev, IPW_REG_RESET_REG, &reg);
1372 1372
1373 if (reg & IPW_AUX_HOST_RESET_REG_MASTER_DISABLED) 1373 if (reg & IPW_AUX_HOST_RESET_REG_MASTER_DISABLED)
1374 break; 1374 break;
1375 } while (--i); 1375 } while (--i);
1376 1376
1377 priv->status &= ~STATUS_RESET_PENDING; 1377 priv->status &= ~STATUS_RESET_PENDING;
1378 1378
1379 if (!i) { 1379 if (!i) {
1380 IPW_DEBUG_INFO 1380 IPW_DEBUG_INFO
1381 ("exit - waited too long for master assert stop\n"); 1381 ("exit - waited too long for master assert stop\n");
1382 return -EIO; 1382 return -EIO;
1383 } 1383 }
1384 1384
1385 write_register(priv->net_dev, IPW_REG_RESET_REG, 1385 write_register(priv->net_dev, IPW_REG_RESET_REG,
1386 IPW_AUX_HOST_RESET_REG_SW_RESET); 1386 IPW_AUX_HOST_RESET_REG_SW_RESET);
1387 1387
1388 /* Reset any fatal_error conditions */ 1388 /* Reset any fatal_error conditions */
1389 ipw2100_reset_fatalerror(priv); 1389 ipw2100_reset_fatalerror(priv);
1390 1390
1391 /* At this point, the adapter is now stopped and disabled */ 1391 /* At this point, the adapter is now stopped and disabled */
1392 priv->status &= ~(STATUS_RUNNING | STATUS_ASSOCIATING | 1392 priv->status &= ~(STATUS_RUNNING | STATUS_ASSOCIATING |
1393 STATUS_ASSOCIATED | STATUS_ENABLED); 1393 STATUS_ASSOCIATED | STATUS_ENABLED);
1394 1394
1395 return 0; 1395 return 0;
1396 } 1396 }
1397 1397
1398 /* 1398 /*
1399 * Send the CARD_DISABLE_PHY_OFF command to the card to disable it 1399 * Send the CARD_DISABLE_PHY_OFF command to the card to disable it
1400 * 1400 *
1401 * After disabling, if the card was associated, a STATUS_ASSN_LOST will be sent. 1401 * After disabling, if the card was associated, a STATUS_ASSN_LOST will be sent.
1402 * 1402 *
1403 * STATUS_CARD_DISABLE_NOTIFICATION will be sent regardless of 1403 * STATUS_CARD_DISABLE_NOTIFICATION will be sent regardless of
1404 * if STATUS_ASSN_LOST is sent. 1404 * if STATUS_ASSN_LOST is sent.
1405 */ 1405 */
1406 static int ipw2100_hw_phy_off(struct ipw2100_priv *priv) 1406 static int ipw2100_hw_phy_off(struct ipw2100_priv *priv)
1407 { 1407 {
1408 1408
1409 #define HW_PHY_OFF_LOOP_DELAY (HZ / 5000) 1409 #define HW_PHY_OFF_LOOP_DELAY (HZ / 5000)
1410 1410
1411 struct host_command cmd = { 1411 struct host_command cmd = {
1412 .host_command = CARD_DISABLE_PHY_OFF, 1412 .host_command = CARD_DISABLE_PHY_OFF,
1413 .host_command_sequence = 0, 1413 .host_command_sequence = 0,
1414 .host_command_length = 0, 1414 .host_command_length = 0,
1415 }; 1415 };
1416 int err, i; 1416 int err, i;
1417 u32 val1, val2; 1417 u32 val1, val2;
1418 1418
1419 IPW_DEBUG_HC("CARD_DISABLE_PHY_OFF\n"); 1419 IPW_DEBUG_HC("CARD_DISABLE_PHY_OFF\n");
1420 1420
1421 /* Turn off the radio */ 1421 /* Turn off the radio */
1422 err = ipw2100_hw_send_command(priv, &cmd); 1422 err = ipw2100_hw_send_command(priv, &cmd);
1423 if (err) 1423 if (err)
1424 return err; 1424 return err;
1425 1425
1426 for (i = 0; i < 2500; i++) { 1426 for (i = 0; i < 2500; i++) {
1427 read_nic_dword(priv->net_dev, IPW2100_CONTROL_REG, &val1); 1427 read_nic_dword(priv->net_dev, IPW2100_CONTROL_REG, &val1);
1428 read_nic_dword(priv->net_dev, IPW2100_COMMAND, &val2); 1428 read_nic_dword(priv->net_dev, IPW2100_COMMAND, &val2);
1429 1429
1430 if ((val1 & IPW2100_CONTROL_PHY_OFF) && 1430 if ((val1 & IPW2100_CONTROL_PHY_OFF) &&
1431 (val2 & IPW2100_COMMAND_PHY_OFF)) 1431 (val2 & IPW2100_COMMAND_PHY_OFF))
1432 return 0; 1432 return 0;
1433 1433
1434 schedule_timeout_uninterruptible(HW_PHY_OFF_LOOP_DELAY); 1434 schedule_timeout_uninterruptible(HW_PHY_OFF_LOOP_DELAY);
1435 } 1435 }
1436 1436
1437 return -EIO; 1437 return -EIO;
1438 } 1438 }
1439 1439
1440 static int ipw2100_enable_adapter(struct ipw2100_priv *priv) 1440 static int ipw2100_enable_adapter(struct ipw2100_priv *priv)
1441 { 1441 {
1442 struct host_command cmd = { 1442 struct host_command cmd = {
1443 .host_command = HOST_COMPLETE, 1443 .host_command = HOST_COMPLETE,
1444 .host_command_sequence = 0, 1444 .host_command_sequence = 0,
1445 .host_command_length = 0 1445 .host_command_length = 0
1446 }; 1446 };
1447 int err = 0; 1447 int err = 0;
1448 1448
1449 IPW_DEBUG_HC("HOST_COMPLETE\n"); 1449 IPW_DEBUG_HC("HOST_COMPLETE\n");
1450 1450
1451 if (priv->status & STATUS_ENABLED) 1451 if (priv->status & STATUS_ENABLED)
1452 return 0; 1452 return 0;
1453 1453
1454 mutex_lock(&priv->adapter_mutex); 1454 mutex_lock(&priv->adapter_mutex);
1455 1455
1456 if (rf_kill_active(priv)) { 1456 if (rf_kill_active(priv)) {
1457 IPW_DEBUG_HC("Command aborted due to RF kill active.\n"); 1457 IPW_DEBUG_HC("Command aborted due to RF kill active.\n");
1458 goto fail_up; 1458 goto fail_up;
1459 } 1459 }
1460 1460
1461 err = ipw2100_hw_send_command(priv, &cmd); 1461 err = ipw2100_hw_send_command(priv, &cmd);
1462 if (err) { 1462 if (err) {
1463 IPW_DEBUG_INFO("Failed to send HOST_COMPLETE command\n"); 1463 IPW_DEBUG_INFO("Failed to send HOST_COMPLETE command\n");
1464 goto fail_up; 1464 goto fail_up;
1465 } 1465 }
1466 1466
1467 err = ipw2100_wait_for_card_state(priv, IPW_HW_STATE_ENABLED); 1467 err = ipw2100_wait_for_card_state(priv, IPW_HW_STATE_ENABLED);
1468 if (err) { 1468 if (err) {
1469 IPW_DEBUG_INFO("%s: card not responding to init command.\n", 1469 IPW_DEBUG_INFO("%s: card not responding to init command.\n",
1470 priv->net_dev->name); 1470 priv->net_dev->name);
1471 goto fail_up; 1471 goto fail_up;
1472 } 1472 }
1473 1473
1474 if (priv->stop_hang_check) { 1474 if (priv->stop_hang_check) {
1475 priv->stop_hang_check = 0; 1475 priv->stop_hang_check = 0;
1476 schedule_delayed_work(&priv->hang_check, HZ / 2); 1476 schedule_delayed_work(&priv->hang_check, HZ / 2);
1477 } 1477 }
1478 1478
1479 fail_up: 1479 fail_up:
1480 mutex_unlock(&priv->adapter_mutex); 1480 mutex_unlock(&priv->adapter_mutex);
1481 return err; 1481 return err;
1482 } 1482 }
1483 1483
1484 static int ipw2100_hw_stop_adapter(struct ipw2100_priv *priv) 1484 static int ipw2100_hw_stop_adapter(struct ipw2100_priv *priv)
1485 { 1485 {
1486 #define HW_POWER_DOWN_DELAY (msecs_to_jiffies(100)) 1486 #define HW_POWER_DOWN_DELAY (msecs_to_jiffies(100))
1487 1487
1488 struct host_command cmd = { 1488 struct host_command cmd = {
1489 .host_command = HOST_PRE_POWER_DOWN, 1489 .host_command = HOST_PRE_POWER_DOWN,
1490 .host_command_sequence = 0, 1490 .host_command_sequence = 0,
1491 .host_command_length = 0, 1491 .host_command_length = 0,
1492 }; 1492 };
1493 int err, i; 1493 int err, i;
1494 u32 reg; 1494 u32 reg;
1495 1495
1496 if (!(priv->status & STATUS_RUNNING)) 1496 if (!(priv->status & STATUS_RUNNING))
1497 return 0; 1497 return 0;
1498 1498
1499 priv->status |= STATUS_STOPPING; 1499 priv->status |= STATUS_STOPPING;
1500 1500
1501 /* We can only shut down the card if the firmware is operational. So, 1501 /* We can only shut down the card if the firmware is operational. So,
1502 * if we haven't reset since a fatal_error, then we can not send the 1502 * if we haven't reset since a fatal_error, then we can not send the
1503 * shutdown commands. */ 1503 * shutdown commands. */
1504 if (!priv->fatal_error) { 1504 if (!priv->fatal_error) {
1505 /* First, make sure the adapter is enabled so that the PHY_OFF 1505 /* First, make sure the adapter is enabled so that the PHY_OFF
1506 * command can shut it down */ 1506 * command can shut it down */
1507 ipw2100_enable_adapter(priv); 1507 ipw2100_enable_adapter(priv);
1508 1508
1509 err = ipw2100_hw_phy_off(priv); 1509 err = ipw2100_hw_phy_off(priv);
1510 if (err) 1510 if (err)
1511 printk(KERN_WARNING DRV_NAME 1511 printk(KERN_WARNING DRV_NAME
1512 ": Error disabling radio %d\n", err); 1512 ": Error disabling radio %d\n", err);
1513 1513
1514 /* 1514 /*
1515 * If in D0-standby mode going directly to D3 may cause a 1515 * If in D0-standby mode going directly to D3 may cause a
1516 * PCI bus violation. Therefore we must change out of the D0 1516 * PCI bus violation. Therefore we must change out of the D0
1517 * state. 1517 * state.
1518 * 1518 *
1519 * Sending the PREPARE_FOR_POWER_DOWN will restrict the 1519 * Sending the PREPARE_FOR_POWER_DOWN will restrict the
1520 * hardware from going into standby mode and will transition 1520 * hardware from going into standby mode and will transition
1521 * out of D0-standby if it is already in that state. 1521 * out of D0-standby if it is already in that state.
1522 * 1522 *
1523 * STATUS_PREPARE_POWER_DOWN_COMPLETE will be sent by the 1523 * STATUS_PREPARE_POWER_DOWN_COMPLETE will be sent by the
1524 * driver upon completion. Once received, the driver can 1524 * driver upon completion. Once received, the driver can
1525 * proceed to the D3 state. 1525 * proceed to the D3 state.
1526 * 1526 *
1527 * Prepare for power down command to fw. This command would 1527 * Prepare for power down command to fw. This command would
1528 * take HW out of D0-standby and prepare it for D3 state. 1528 * take HW out of D0-standby and prepare it for D3 state.
1529 * 1529 *
1530 * Currently FW does not support event notification for this 1530 * Currently FW does not support event notification for this
1531 * event. Therefore, skip waiting for it. Just wait a fixed 1531 * event. Therefore, skip waiting for it. Just wait a fixed
1532 * 100ms 1532 * 100ms
1533 */ 1533 */
1534 IPW_DEBUG_HC("HOST_PRE_POWER_DOWN\n"); 1534 IPW_DEBUG_HC("HOST_PRE_POWER_DOWN\n");
1535 1535
1536 err = ipw2100_hw_send_command(priv, &cmd); 1536 err = ipw2100_hw_send_command(priv, &cmd);
1537 if (err) 1537 if (err)
1538 printk(KERN_WARNING DRV_NAME ": " 1538 printk(KERN_WARNING DRV_NAME ": "
1539 "%s: Power down command failed: Error %d\n", 1539 "%s: Power down command failed: Error %d\n",
1540 priv->net_dev->name, err); 1540 priv->net_dev->name, err);
1541 else 1541 else
1542 schedule_timeout_uninterruptible(HW_POWER_DOWN_DELAY); 1542 schedule_timeout_uninterruptible(HW_POWER_DOWN_DELAY);
1543 } 1543 }
1544 1544
1545 priv->status &= ~STATUS_ENABLED; 1545 priv->status &= ~STATUS_ENABLED;
1546 1546
1547 /* 1547 /*
1548 * Set GPIO 3 writable by FW; GPIO 1 writable 1548 * Set GPIO 3 writable by FW; GPIO 1 writable
1549 * by driver and enable clock 1549 * by driver and enable clock
1550 */ 1550 */
1551 ipw2100_hw_set_gpio(priv); 1551 ipw2100_hw_set_gpio(priv);
1552 1552
1553 /* 1553 /*
1554 * Power down adapter. Sequence: 1554 * Power down adapter. Sequence:
1555 * 1. Stop master assert (RESET_REG[9]=1) 1555 * 1. Stop master assert (RESET_REG[9]=1)
1556 * 2. Wait for stop master (RESET_REG[8]==1) 1556 * 2. Wait for stop master (RESET_REG[8]==1)
1557 * 3. S/w reset assert (RESET_REG[7] = 1) 1557 * 3. S/w reset assert (RESET_REG[7] = 1)
1558 */ 1558 */
1559 1559
1560 /* Stop master assert */ 1560 /* Stop master assert */
1561 write_register(priv->net_dev, IPW_REG_RESET_REG, 1561 write_register(priv->net_dev, IPW_REG_RESET_REG,
1562 IPW_AUX_HOST_RESET_REG_STOP_MASTER); 1562 IPW_AUX_HOST_RESET_REG_STOP_MASTER);
1563 1563
1564 /* wait stop master not more than 50 usec. 1564 /* wait stop master not more than 50 usec.
1565 * Otherwise return error. */ 1565 * Otherwise return error. */
1566 for (i = 5; i > 0; i--) { 1566 for (i = 5; i > 0; i--) {
1567 udelay(10); 1567 udelay(10);
1568 1568
1569 /* Check master stop bit */ 1569 /* Check master stop bit */
1570 read_register(priv->net_dev, IPW_REG_RESET_REG, &reg); 1570 read_register(priv->net_dev, IPW_REG_RESET_REG, &reg);
1571 1571
1572 if (reg & IPW_AUX_HOST_RESET_REG_MASTER_DISABLED) 1572 if (reg & IPW_AUX_HOST_RESET_REG_MASTER_DISABLED)
1573 break; 1573 break;
1574 } 1574 }
1575 1575
1576 if (i == 0) 1576 if (i == 0)
1577 printk(KERN_WARNING DRV_NAME 1577 printk(KERN_WARNING DRV_NAME
1578 ": %s: Could now power down adapter.\n", 1578 ": %s: Could now power down adapter.\n",
1579 priv->net_dev->name); 1579 priv->net_dev->name);
1580 1580
1581 /* assert s/w reset */ 1581 /* assert s/w reset */
1582 write_register(priv->net_dev, IPW_REG_RESET_REG, 1582 write_register(priv->net_dev, IPW_REG_RESET_REG,
1583 IPW_AUX_HOST_RESET_REG_SW_RESET); 1583 IPW_AUX_HOST_RESET_REG_SW_RESET);
1584 1584
1585 priv->status &= ~(STATUS_RUNNING | STATUS_STOPPING); 1585 priv->status &= ~(STATUS_RUNNING | STATUS_STOPPING);
1586 1586
1587 return 0; 1587 return 0;
1588 } 1588 }
1589 1589
1590 static int ipw2100_disable_adapter(struct ipw2100_priv *priv) 1590 static int ipw2100_disable_adapter(struct ipw2100_priv *priv)
1591 { 1591 {
1592 struct host_command cmd = { 1592 struct host_command cmd = {
1593 .host_command = CARD_DISABLE, 1593 .host_command = CARD_DISABLE,
1594 .host_command_sequence = 0, 1594 .host_command_sequence = 0,
1595 .host_command_length = 0 1595 .host_command_length = 0
1596 }; 1596 };
1597 int err = 0; 1597 int err = 0;
1598 1598
1599 IPW_DEBUG_HC("CARD_DISABLE\n"); 1599 IPW_DEBUG_HC("CARD_DISABLE\n");
1600 1600
1601 if (!(priv->status & STATUS_ENABLED)) 1601 if (!(priv->status & STATUS_ENABLED))
1602 return 0; 1602 return 0;
1603 1603
1604 /* Make sure we clear the associated state */ 1604 /* Make sure we clear the associated state */
1605 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING); 1605 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
1606 1606
1607 if (!priv->stop_hang_check) { 1607 if (!priv->stop_hang_check) {
1608 priv->stop_hang_check = 1; 1608 priv->stop_hang_check = 1;
1609 cancel_delayed_work(&priv->hang_check); 1609 cancel_delayed_work(&priv->hang_check);
1610 } 1610 }
1611 1611
1612 mutex_lock(&priv->adapter_mutex); 1612 mutex_lock(&priv->adapter_mutex);
1613 1613
1614 err = ipw2100_hw_send_command(priv, &cmd); 1614 err = ipw2100_hw_send_command(priv, &cmd);
1615 if (err) { 1615 if (err) {
1616 printk(KERN_WARNING DRV_NAME 1616 printk(KERN_WARNING DRV_NAME
1617 ": exit - failed to send CARD_DISABLE command\n"); 1617 ": exit - failed to send CARD_DISABLE command\n");
1618 goto fail_up; 1618 goto fail_up;
1619 } 1619 }
1620 1620
1621 err = ipw2100_wait_for_card_state(priv, IPW_HW_STATE_DISABLED); 1621 err = ipw2100_wait_for_card_state(priv, IPW_HW_STATE_DISABLED);
1622 if (err) { 1622 if (err) {
1623 printk(KERN_WARNING DRV_NAME 1623 printk(KERN_WARNING DRV_NAME
1624 ": exit - card failed to change to DISABLED\n"); 1624 ": exit - card failed to change to DISABLED\n");
1625 goto fail_up; 1625 goto fail_up;
1626 } 1626 }
1627 1627
1628 IPW_DEBUG_INFO("TODO: implement scan state machine\n"); 1628 IPW_DEBUG_INFO("TODO: implement scan state machine\n");
1629 1629
1630 fail_up: 1630 fail_up:
1631 mutex_unlock(&priv->adapter_mutex); 1631 mutex_unlock(&priv->adapter_mutex);
1632 return err; 1632 return err;
1633 } 1633 }
1634 1634
1635 static int ipw2100_set_scan_options(struct ipw2100_priv *priv) 1635 static int ipw2100_set_scan_options(struct ipw2100_priv *priv)
1636 { 1636 {
1637 struct host_command cmd = { 1637 struct host_command cmd = {
1638 .host_command = SET_SCAN_OPTIONS, 1638 .host_command = SET_SCAN_OPTIONS,
1639 .host_command_sequence = 0, 1639 .host_command_sequence = 0,
1640 .host_command_length = 8 1640 .host_command_length = 8
1641 }; 1641 };
1642 int err; 1642 int err;
1643 1643
1644 IPW_DEBUG_INFO("enter\n"); 1644 IPW_DEBUG_INFO("enter\n");
1645 1645
1646 IPW_DEBUG_SCAN("setting scan options\n"); 1646 IPW_DEBUG_SCAN("setting scan options\n");
1647 1647
1648 cmd.host_command_parameters[0] = 0; 1648 cmd.host_command_parameters[0] = 0;
1649 1649
1650 if (!(priv->config & CFG_ASSOCIATE)) 1650 if (!(priv->config & CFG_ASSOCIATE))
1651 cmd.host_command_parameters[0] |= IPW_SCAN_NOASSOCIATE; 1651 cmd.host_command_parameters[0] |= IPW_SCAN_NOASSOCIATE;
1652 if ((priv->ieee->sec.flags & SEC_ENABLED) && priv->ieee->sec.enabled) 1652 if ((priv->ieee->sec.flags & SEC_ENABLED) && priv->ieee->sec.enabled)
1653 cmd.host_command_parameters[0] |= IPW_SCAN_MIXED_CELL; 1653 cmd.host_command_parameters[0] |= IPW_SCAN_MIXED_CELL;
1654 if (priv->config & CFG_PASSIVE_SCAN) 1654 if (priv->config & CFG_PASSIVE_SCAN)
1655 cmd.host_command_parameters[0] |= IPW_SCAN_PASSIVE; 1655 cmd.host_command_parameters[0] |= IPW_SCAN_PASSIVE;
1656 1656
1657 cmd.host_command_parameters[1] = priv->channel_mask; 1657 cmd.host_command_parameters[1] = priv->channel_mask;
1658 1658
1659 err = ipw2100_hw_send_command(priv, &cmd); 1659 err = ipw2100_hw_send_command(priv, &cmd);
1660 1660
1661 IPW_DEBUG_HC("SET_SCAN_OPTIONS 0x%04X\n", 1661 IPW_DEBUG_HC("SET_SCAN_OPTIONS 0x%04X\n",
1662 cmd.host_command_parameters[0]); 1662 cmd.host_command_parameters[0]);
1663 1663
1664 return err; 1664 return err;
1665 } 1665 }
1666 1666
1667 static int ipw2100_start_scan(struct ipw2100_priv *priv) 1667 static int ipw2100_start_scan(struct ipw2100_priv *priv)
1668 { 1668 {
1669 struct host_command cmd = { 1669 struct host_command cmd = {
1670 .host_command = BROADCAST_SCAN, 1670 .host_command = BROADCAST_SCAN,
1671 .host_command_sequence = 0, 1671 .host_command_sequence = 0,
1672 .host_command_length = 4 1672 .host_command_length = 4
1673 }; 1673 };
1674 int err; 1674 int err;
1675 1675
1676 IPW_DEBUG_HC("START_SCAN\n"); 1676 IPW_DEBUG_HC("START_SCAN\n");
1677 1677
1678 cmd.host_command_parameters[0] = 0; 1678 cmd.host_command_parameters[0] = 0;
1679 1679
1680 /* No scanning if in monitor mode */ 1680 /* No scanning if in monitor mode */
1681 if (priv->ieee->iw_mode == IW_MODE_MONITOR) 1681 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
1682 return 1; 1682 return 1;
1683 1683
1684 if (priv->status & STATUS_SCANNING) { 1684 if (priv->status & STATUS_SCANNING) {
1685 IPW_DEBUG_SCAN("Scan requested while already in scan...\n"); 1685 IPW_DEBUG_SCAN("Scan requested while already in scan...\n");
1686 return 0; 1686 return 0;
1687 } 1687 }
1688 1688
1689 IPW_DEBUG_INFO("enter\n"); 1689 IPW_DEBUG_INFO("enter\n");
1690 1690
1691 /* Not clearing here; doing so makes iwlist always return nothing... 1691 /* Not clearing here; doing so makes iwlist always return nothing...
1692 * 1692 *
1693 * We should modify the table logic to use aging tables vs. clearing 1693 * We should modify the table logic to use aging tables vs. clearing
1694 * the table on each scan start. 1694 * the table on each scan start.
1695 */ 1695 */
1696 IPW_DEBUG_SCAN("starting scan\n"); 1696 IPW_DEBUG_SCAN("starting scan\n");
1697 1697
1698 priv->status |= STATUS_SCANNING; 1698 priv->status |= STATUS_SCANNING;
1699 err = ipw2100_hw_send_command(priv, &cmd); 1699 err = ipw2100_hw_send_command(priv, &cmd);
1700 if (err) 1700 if (err)
1701 priv->status &= ~STATUS_SCANNING; 1701 priv->status &= ~STATUS_SCANNING;
1702 1702
1703 IPW_DEBUG_INFO("exit\n"); 1703 IPW_DEBUG_INFO("exit\n");
1704 1704
1705 return err; 1705 return err;
1706 } 1706 }
1707 1707
1708 static const struct libipw_geo ipw_geos[] = { 1708 static const struct libipw_geo ipw_geos[] = {
1709 { /* Restricted */ 1709 { /* Restricted */
1710 "---", 1710 "---",
1711 .bg_channels = 14, 1711 .bg_channels = 14,
1712 .bg = {{2412, 1}, {2417, 2}, {2422, 3}, 1712 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
1713 {2427, 4}, {2432, 5}, {2437, 6}, 1713 {2427, 4}, {2432, 5}, {2437, 6},
1714 {2442, 7}, {2447, 8}, {2452, 9}, 1714 {2442, 7}, {2447, 8}, {2452, 9},
1715 {2457, 10}, {2462, 11}, {2467, 12}, 1715 {2457, 10}, {2462, 11}, {2467, 12},
1716 {2472, 13}, {2484, 14}}, 1716 {2472, 13}, {2484, 14}},
1717 }, 1717 },
1718 }; 1718 };
1719 1719
1720 static int ipw2100_up(struct ipw2100_priv *priv, int deferred) 1720 static int ipw2100_up(struct ipw2100_priv *priv, int deferred)
1721 { 1721 {
1722 unsigned long flags; 1722 unsigned long flags;
1723 int rc = 0; 1723 int rc = 0;
1724 u32 lock; 1724 u32 lock;
1725 u32 ord_len = sizeof(lock); 1725 u32 ord_len = sizeof(lock);
1726 1726
1727 /* Age scan list entries found before suspend */ 1727 /* Age scan list entries found before suspend */
1728 if (priv->suspend_time) { 1728 if (priv->suspend_time) {
1729 libipw_networks_age(priv->ieee, priv->suspend_time); 1729 libipw_networks_age(priv->ieee, priv->suspend_time);
1730 priv->suspend_time = 0; 1730 priv->suspend_time = 0;
1731 } 1731 }
1732 1732
1733 /* Quiet if manually disabled. */ 1733 /* Quiet if manually disabled. */
1734 if (priv->status & STATUS_RF_KILL_SW) { 1734 if (priv->status & STATUS_RF_KILL_SW) {
1735 IPW_DEBUG_INFO("%s: Radio is disabled by Manual Disable " 1735 IPW_DEBUG_INFO("%s: Radio is disabled by Manual Disable "
1736 "switch\n", priv->net_dev->name); 1736 "switch\n", priv->net_dev->name);
1737 return 0; 1737 return 0;
1738 } 1738 }
1739 1739
1740 /* the ipw2100 hardware really doesn't want power management delays 1740 /* the ipw2100 hardware really doesn't want power management delays
1741 * longer than 175usec 1741 * longer than 175usec
1742 */ 1742 */
1743 pm_qos_update_request(&ipw2100_pm_qos_req, 175); 1743 pm_qos_update_request(&ipw2100_pm_qos_req, 175);
1744 1744
1745 /* If the interrupt is enabled, turn it off... */ 1745 /* If the interrupt is enabled, turn it off... */
1746 spin_lock_irqsave(&priv->low_lock, flags); 1746 spin_lock_irqsave(&priv->low_lock, flags);
1747 ipw2100_disable_interrupts(priv); 1747 ipw2100_disable_interrupts(priv);
1748 1748
1749 /* Reset any fatal_error conditions */ 1749 /* Reset any fatal_error conditions */
1750 ipw2100_reset_fatalerror(priv); 1750 ipw2100_reset_fatalerror(priv);
1751 spin_unlock_irqrestore(&priv->low_lock, flags); 1751 spin_unlock_irqrestore(&priv->low_lock, flags);
1752 1752
1753 if (priv->status & STATUS_POWERED || 1753 if (priv->status & STATUS_POWERED ||
1754 (priv->status & STATUS_RESET_PENDING)) { 1754 (priv->status & STATUS_RESET_PENDING)) {
1755 /* Power cycle the card ... */ 1755 /* Power cycle the card ... */
1756 if (ipw2100_power_cycle_adapter(priv)) { 1756 if (ipw2100_power_cycle_adapter(priv)) {
1757 printk(KERN_WARNING DRV_NAME 1757 printk(KERN_WARNING DRV_NAME
1758 ": %s: Could not cycle adapter.\n", 1758 ": %s: Could not cycle adapter.\n",
1759 priv->net_dev->name); 1759 priv->net_dev->name);
1760 rc = 1; 1760 rc = 1;
1761 goto exit; 1761 goto exit;
1762 } 1762 }
1763 } else 1763 } else
1764 priv->status |= STATUS_POWERED; 1764 priv->status |= STATUS_POWERED;
1765 1765
1766 /* Load the firmware, start the clocks, etc. */ 1766 /* Load the firmware, start the clocks, etc. */
1767 if (ipw2100_start_adapter(priv)) { 1767 if (ipw2100_start_adapter(priv)) {
1768 printk(KERN_ERR DRV_NAME 1768 printk(KERN_ERR DRV_NAME
1769 ": %s: Failed to start the firmware.\n", 1769 ": %s: Failed to start the firmware.\n",
1770 priv->net_dev->name); 1770 priv->net_dev->name);
1771 rc = 1; 1771 rc = 1;
1772 goto exit; 1772 goto exit;
1773 } 1773 }
1774 1774
1775 ipw2100_initialize_ordinals(priv); 1775 ipw2100_initialize_ordinals(priv);
1776 1776
1777 /* Determine capabilities of this particular HW configuration */ 1777 /* Determine capabilities of this particular HW configuration */
1778 if (ipw2100_get_hw_features(priv)) { 1778 if (ipw2100_get_hw_features(priv)) {
1779 printk(KERN_ERR DRV_NAME 1779 printk(KERN_ERR DRV_NAME
1780 ": %s: Failed to determine HW features.\n", 1780 ": %s: Failed to determine HW features.\n",
1781 priv->net_dev->name); 1781 priv->net_dev->name);
1782 rc = 1; 1782 rc = 1;
1783 goto exit; 1783 goto exit;
1784 } 1784 }
1785 1785
1786 /* Initialize the geo */ 1786 /* Initialize the geo */
1787 if (libipw_set_geo(priv->ieee, &ipw_geos[0])) { 1787 if (libipw_set_geo(priv->ieee, &ipw_geos[0])) {
1788 printk(KERN_WARNING DRV_NAME "Could not set geo\n"); 1788 printk(KERN_WARNING DRV_NAME "Could not set geo\n");
1789 return 0; 1789 return 0;
1790 } 1790 }
1791 priv->ieee->freq_band = LIBIPW_24GHZ_BAND; 1791 priv->ieee->freq_band = LIBIPW_24GHZ_BAND;
1792 1792
1793 lock = LOCK_NONE; 1793 lock = LOCK_NONE;
1794 if (ipw2100_set_ordinal(priv, IPW_ORD_PERS_DB_LOCK, &lock, &ord_len)) { 1794 if (ipw2100_set_ordinal(priv, IPW_ORD_PERS_DB_LOCK, &lock, &ord_len)) {
1795 printk(KERN_ERR DRV_NAME 1795 printk(KERN_ERR DRV_NAME
1796 ": %s: Failed to clear ordinal lock.\n", 1796 ": %s: Failed to clear ordinal lock.\n",
1797 priv->net_dev->name); 1797 priv->net_dev->name);
1798 rc = 1; 1798 rc = 1;
1799 goto exit; 1799 goto exit;
1800 } 1800 }
1801 1801
1802 priv->status &= ~STATUS_SCANNING; 1802 priv->status &= ~STATUS_SCANNING;
1803 1803
1804 if (rf_kill_active(priv)) { 1804 if (rf_kill_active(priv)) {
1805 printk(KERN_INFO "%s: Radio is disabled by RF switch.\n", 1805 printk(KERN_INFO "%s: Radio is disabled by RF switch.\n",
1806 priv->net_dev->name); 1806 priv->net_dev->name);
1807 1807
1808 if (priv->stop_rf_kill) { 1808 if (priv->stop_rf_kill) {
1809 priv->stop_rf_kill = 0; 1809 priv->stop_rf_kill = 0;
1810 schedule_delayed_work(&priv->rf_kill, 1810 schedule_delayed_work(&priv->rf_kill,
1811 round_jiffies_relative(HZ)); 1811 round_jiffies_relative(HZ));
1812 } 1812 }
1813 1813
1814 deferred = 1; 1814 deferred = 1;
1815 } 1815 }
1816 1816
1817 /* Turn on the interrupt so that commands can be processed */ 1817 /* Turn on the interrupt so that commands can be processed */
1818 ipw2100_enable_interrupts(priv); 1818 ipw2100_enable_interrupts(priv);
1819 1819
1820 /* Send all of the commands that must be sent prior to 1820 /* Send all of the commands that must be sent prior to
1821 * HOST_COMPLETE */ 1821 * HOST_COMPLETE */
1822 if (ipw2100_adapter_setup(priv)) { 1822 if (ipw2100_adapter_setup(priv)) {
1823 printk(KERN_ERR DRV_NAME ": %s: Failed to start the card.\n", 1823 printk(KERN_ERR DRV_NAME ": %s: Failed to start the card.\n",
1824 priv->net_dev->name); 1824 priv->net_dev->name);
1825 rc = 1; 1825 rc = 1;
1826 goto exit; 1826 goto exit;
1827 } 1827 }
1828 1828
1829 if (!deferred) { 1829 if (!deferred) {
1830 /* Enable the adapter - sends HOST_COMPLETE */ 1830 /* Enable the adapter - sends HOST_COMPLETE */
1831 if (ipw2100_enable_adapter(priv)) { 1831 if (ipw2100_enable_adapter(priv)) {
1832 printk(KERN_ERR DRV_NAME ": " 1832 printk(KERN_ERR DRV_NAME ": "
1833 "%s: failed in call to enable adapter.\n", 1833 "%s: failed in call to enable adapter.\n",
1834 priv->net_dev->name); 1834 priv->net_dev->name);
1835 ipw2100_hw_stop_adapter(priv); 1835 ipw2100_hw_stop_adapter(priv);
1836 rc = 1; 1836 rc = 1;
1837 goto exit; 1837 goto exit;
1838 } 1838 }
1839 1839
1840 /* Start a scan . . . */ 1840 /* Start a scan . . . */
1841 ipw2100_set_scan_options(priv); 1841 ipw2100_set_scan_options(priv);
1842 ipw2100_start_scan(priv); 1842 ipw2100_start_scan(priv);
1843 } 1843 }
1844 1844
1845 exit: 1845 exit:
1846 return rc; 1846 return rc;
1847 } 1847 }
1848 1848
1849 static void ipw2100_down(struct ipw2100_priv *priv) 1849 static void ipw2100_down(struct ipw2100_priv *priv)
1850 { 1850 {
1851 unsigned long flags; 1851 unsigned long flags;
1852 union iwreq_data wrqu = { 1852 union iwreq_data wrqu = {
1853 .ap_addr = { 1853 .ap_addr = {
1854 .sa_family = ARPHRD_ETHER} 1854 .sa_family = ARPHRD_ETHER}
1855 }; 1855 };
1856 int associated = priv->status & STATUS_ASSOCIATED; 1856 int associated = priv->status & STATUS_ASSOCIATED;
1857 1857
1858 /* Kill the RF switch timer */ 1858 /* Kill the RF switch timer */
1859 if (!priv->stop_rf_kill) { 1859 if (!priv->stop_rf_kill) {
1860 priv->stop_rf_kill = 1; 1860 priv->stop_rf_kill = 1;
1861 cancel_delayed_work(&priv->rf_kill); 1861 cancel_delayed_work(&priv->rf_kill);
1862 } 1862 }
1863 1863
1864 /* Kill the firmware hang check timer */ 1864 /* Kill the firmware hang check timer */
1865 if (!priv->stop_hang_check) { 1865 if (!priv->stop_hang_check) {
1866 priv->stop_hang_check = 1; 1866 priv->stop_hang_check = 1;
1867 cancel_delayed_work(&priv->hang_check); 1867 cancel_delayed_work(&priv->hang_check);
1868 } 1868 }
1869 1869
1870 /* Kill any pending resets */ 1870 /* Kill any pending resets */
1871 if (priv->status & STATUS_RESET_PENDING) 1871 if (priv->status & STATUS_RESET_PENDING)
1872 cancel_delayed_work(&priv->reset_work); 1872 cancel_delayed_work(&priv->reset_work);
1873 1873
1874 /* Make sure the interrupt is on so that FW commands will be 1874 /* Make sure the interrupt is on so that FW commands will be
1875 * processed correctly */ 1875 * processed correctly */
1876 spin_lock_irqsave(&priv->low_lock, flags); 1876 spin_lock_irqsave(&priv->low_lock, flags);
1877 ipw2100_enable_interrupts(priv); 1877 ipw2100_enable_interrupts(priv);
1878 spin_unlock_irqrestore(&priv->low_lock, flags); 1878 spin_unlock_irqrestore(&priv->low_lock, flags);
1879 1879
1880 if (ipw2100_hw_stop_adapter(priv)) 1880 if (ipw2100_hw_stop_adapter(priv))
1881 printk(KERN_ERR DRV_NAME ": %s: Error stopping adapter.\n", 1881 printk(KERN_ERR DRV_NAME ": %s: Error stopping adapter.\n",
1882 priv->net_dev->name); 1882 priv->net_dev->name);
1883 1883
1884 /* Do not disable the interrupt until _after_ we disable 1884 /* Do not disable the interrupt until _after_ we disable
1885 * the adaptor. Otherwise the CARD_DISABLE command will never 1885 * the adaptor. Otherwise the CARD_DISABLE command will never
1886 * be ack'd by the firmware */ 1886 * be ack'd by the firmware */
1887 spin_lock_irqsave(&priv->low_lock, flags); 1887 spin_lock_irqsave(&priv->low_lock, flags);
1888 ipw2100_disable_interrupts(priv); 1888 ipw2100_disable_interrupts(priv);
1889 spin_unlock_irqrestore(&priv->low_lock, flags); 1889 spin_unlock_irqrestore(&priv->low_lock, flags);
1890 1890
1891 pm_qos_update_request(&ipw2100_pm_qos_req, PM_QOS_DEFAULT_VALUE); 1891 pm_qos_update_request(&ipw2100_pm_qos_req, PM_QOS_DEFAULT_VALUE);
1892 1892
1893 /* We have to signal any supplicant if we are disassociating */ 1893 /* We have to signal any supplicant if we are disassociating */
1894 if (associated) 1894 if (associated)
1895 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL); 1895 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1896 1896
1897 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING); 1897 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
1898 netif_carrier_off(priv->net_dev); 1898 netif_carrier_off(priv->net_dev);
1899 netif_stop_queue(priv->net_dev); 1899 netif_stop_queue(priv->net_dev);
1900 } 1900 }
1901 1901
1902 /* Called by register_netdev() */ 1902 /* Called by register_netdev() */
1903 static int ipw2100_net_init(struct net_device *dev) 1903 static int ipw2100_net_init(struct net_device *dev)
1904 { 1904 {
1905 struct ipw2100_priv *priv = libipw_priv(dev); 1905 struct ipw2100_priv *priv = libipw_priv(dev);
1906 const struct libipw_geo *geo = libipw_get_geo(priv->ieee); 1906 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
1907 struct wireless_dev *wdev = &priv->ieee->wdev; 1907 struct wireless_dev *wdev = &priv->ieee->wdev;
1908 int ret; 1908 int ret;
1909 int i; 1909 int i;
1910 1910
1911 ret = ipw2100_up(priv, 1); 1911 ret = ipw2100_up(priv, 1);
1912 if (ret) 1912 if (ret)
1913 return ret; 1913 return ret;
1914 1914
1915 memcpy(wdev->wiphy->perm_addr, priv->mac_addr, ETH_ALEN); 1915 memcpy(wdev->wiphy->perm_addr, priv->mac_addr, ETH_ALEN);
1916 1916
1917 /* fill-out priv->ieee->bg_band */ 1917 /* fill-out priv->ieee->bg_band */
1918 if (geo->bg_channels) { 1918 if (geo->bg_channels) {
1919 struct ieee80211_supported_band *bg_band = &priv->ieee->bg_band; 1919 struct ieee80211_supported_band *bg_band = &priv->ieee->bg_band;
1920 1920
1921 bg_band->band = IEEE80211_BAND_2GHZ; 1921 bg_band->band = IEEE80211_BAND_2GHZ;
1922 bg_band->n_channels = geo->bg_channels; 1922 bg_band->n_channels = geo->bg_channels;
1923 bg_band->channels = kcalloc(geo->bg_channels, 1923 bg_band->channels = kcalloc(geo->bg_channels,
1924 sizeof(struct ieee80211_channel), 1924 sizeof(struct ieee80211_channel),
1925 GFP_KERNEL); 1925 GFP_KERNEL);
1926 if (!bg_band->channels) { 1926 if (!bg_band->channels) {
1927 ipw2100_down(priv); 1927 ipw2100_down(priv);
1928 return -ENOMEM; 1928 return -ENOMEM;
1929 } 1929 }
1930 /* translate geo->bg to bg_band.channels */ 1930 /* translate geo->bg to bg_band.channels */
1931 for (i = 0; i < geo->bg_channels; i++) { 1931 for (i = 0; i < geo->bg_channels; i++) {
1932 bg_band->channels[i].band = IEEE80211_BAND_2GHZ; 1932 bg_band->channels[i].band = IEEE80211_BAND_2GHZ;
1933 bg_band->channels[i].center_freq = geo->bg[i].freq; 1933 bg_band->channels[i].center_freq = geo->bg[i].freq;
1934 bg_band->channels[i].hw_value = geo->bg[i].channel; 1934 bg_band->channels[i].hw_value = geo->bg[i].channel;
1935 bg_band->channels[i].max_power = geo->bg[i].max_power; 1935 bg_band->channels[i].max_power = geo->bg[i].max_power;
1936 if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY) 1936 if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY)
1937 bg_band->channels[i].flags |= 1937 bg_band->channels[i].flags |=
1938 IEEE80211_CHAN_PASSIVE_SCAN; 1938 IEEE80211_CHAN_PASSIVE_SCAN;
1939 if (geo->bg[i].flags & LIBIPW_CH_NO_IBSS) 1939 if (geo->bg[i].flags & LIBIPW_CH_NO_IBSS)
1940 bg_band->channels[i].flags |= 1940 bg_band->channels[i].flags |=
1941 IEEE80211_CHAN_NO_IBSS; 1941 IEEE80211_CHAN_NO_IBSS;
1942 if (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT) 1942 if (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT)
1943 bg_band->channels[i].flags |= 1943 bg_band->channels[i].flags |=
1944 IEEE80211_CHAN_RADAR; 1944 IEEE80211_CHAN_RADAR;
1945 /* No equivalent for LIBIPW_CH_80211H_RULES, 1945 /* No equivalent for LIBIPW_CH_80211H_RULES,
1946 LIBIPW_CH_UNIFORM_SPREADING, or 1946 LIBIPW_CH_UNIFORM_SPREADING, or
1947 LIBIPW_CH_B_ONLY... */ 1947 LIBIPW_CH_B_ONLY... */
1948 } 1948 }
1949 /* point at bitrate info */ 1949 /* point at bitrate info */
1950 bg_band->bitrates = ipw2100_bg_rates; 1950 bg_band->bitrates = ipw2100_bg_rates;
1951 bg_band->n_bitrates = RATE_COUNT; 1951 bg_band->n_bitrates = RATE_COUNT;
1952 1952
1953 wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = bg_band; 1953 wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = bg_band;
1954 } 1954 }
1955 1955
1956 set_wiphy_dev(wdev->wiphy, &priv->pci_dev->dev); 1956 set_wiphy_dev(wdev->wiphy, &priv->pci_dev->dev);
1957 if (wiphy_register(wdev->wiphy)) { 1957 if (wiphy_register(wdev->wiphy)) {
1958 ipw2100_down(priv); 1958 ipw2100_down(priv);
1959 return -EIO; 1959 return -EIO;
1960 } 1960 }
1961 return 0; 1961 return 0;
1962 } 1962 }
1963 1963
1964 static void ipw2100_reset_adapter(struct work_struct *work) 1964 static void ipw2100_reset_adapter(struct work_struct *work)
1965 { 1965 {
1966 struct ipw2100_priv *priv = 1966 struct ipw2100_priv *priv =
1967 container_of(work, struct ipw2100_priv, reset_work.work); 1967 container_of(work, struct ipw2100_priv, reset_work.work);
1968 unsigned long flags; 1968 unsigned long flags;
1969 union iwreq_data wrqu = { 1969 union iwreq_data wrqu = {
1970 .ap_addr = { 1970 .ap_addr = {
1971 .sa_family = ARPHRD_ETHER} 1971 .sa_family = ARPHRD_ETHER}
1972 }; 1972 };
1973 int associated = priv->status & STATUS_ASSOCIATED; 1973 int associated = priv->status & STATUS_ASSOCIATED;
1974 1974
1975 spin_lock_irqsave(&priv->low_lock, flags); 1975 spin_lock_irqsave(&priv->low_lock, flags);
1976 IPW_DEBUG_INFO(": %s: Restarting adapter.\n", priv->net_dev->name); 1976 IPW_DEBUG_INFO(": %s: Restarting adapter.\n", priv->net_dev->name);
1977 priv->resets++; 1977 priv->resets++;
1978 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING); 1978 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
1979 priv->status |= STATUS_SECURITY_UPDATED; 1979 priv->status |= STATUS_SECURITY_UPDATED;
1980 1980
1981 /* Force a power cycle even if interface hasn't been opened 1981 /* Force a power cycle even if interface hasn't been opened
1982 * yet */ 1982 * yet */
1983 cancel_delayed_work(&priv->reset_work); 1983 cancel_delayed_work(&priv->reset_work);
1984 priv->status |= STATUS_RESET_PENDING; 1984 priv->status |= STATUS_RESET_PENDING;
1985 spin_unlock_irqrestore(&priv->low_lock, flags); 1985 spin_unlock_irqrestore(&priv->low_lock, flags);
1986 1986
1987 mutex_lock(&priv->action_mutex); 1987 mutex_lock(&priv->action_mutex);
1988 /* stop timed checks so that they don't interfere with reset */ 1988 /* stop timed checks so that they don't interfere with reset */
1989 priv->stop_hang_check = 1; 1989 priv->stop_hang_check = 1;
1990 cancel_delayed_work(&priv->hang_check); 1990 cancel_delayed_work(&priv->hang_check);
1991 1991
1992 /* We have to signal any supplicant if we are disassociating */ 1992 /* We have to signal any supplicant if we are disassociating */
1993 if (associated) 1993 if (associated)
1994 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL); 1994 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1995 1995
1996 ipw2100_up(priv, 0); 1996 ipw2100_up(priv, 0);
1997 mutex_unlock(&priv->action_mutex); 1997 mutex_unlock(&priv->action_mutex);
1998 1998
1999 } 1999 }
2000 2000
2001 static void isr_indicate_associated(struct ipw2100_priv *priv, u32 status) 2001 static void isr_indicate_associated(struct ipw2100_priv *priv, u32 status)
2002 { 2002 {
2003 2003
2004 #define MAC_ASSOCIATION_READ_DELAY (HZ) 2004 #define MAC_ASSOCIATION_READ_DELAY (HZ)
2005 int ret; 2005 int ret;
2006 unsigned int len, essid_len; 2006 unsigned int len, essid_len;
2007 char essid[IW_ESSID_MAX_SIZE]; 2007 char essid[IW_ESSID_MAX_SIZE];
2008 u32 txrate; 2008 u32 txrate;
2009 u32 chan; 2009 u32 chan;
2010 char *txratename; 2010 char *txratename;
2011 u8 bssid[ETH_ALEN]; 2011 u8 bssid[ETH_ALEN];
2012 DECLARE_SSID_BUF(ssid); 2012 DECLARE_SSID_BUF(ssid);
2013 2013
2014 /* 2014 /*
2015 * TBD: BSSID is usually 00:00:00:00:00:00 here and not 2015 * TBD: BSSID is usually 00:00:00:00:00:00 here and not
2016 * an actual MAC of the AP. Seems like FW sets this 2016 * an actual MAC of the AP. Seems like FW sets this
2017 * address too late. Read it later and expose through 2017 * address too late. Read it later and expose through
2018 * /proc or schedule a later task to query and update 2018 * /proc or schedule a later task to query and update
2019 */ 2019 */
2020 2020
2021 essid_len = IW_ESSID_MAX_SIZE; 2021 essid_len = IW_ESSID_MAX_SIZE;
2022 ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_SSID, 2022 ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_SSID,
2023 essid, &essid_len); 2023 essid, &essid_len);
2024 if (ret) { 2024 if (ret) {
2025 IPW_DEBUG_INFO("failed querying ordinals at line %d\n", 2025 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
2026 __LINE__); 2026 __LINE__);
2027 return; 2027 return;
2028 } 2028 }
2029 2029
2030 len = sizeof(u32); 2030 len = sizeof(u32);
2031 ret = ipw2100_get_ordinal(priv, IPW_ORD_CURRENT_TX_RATE, &txrate, &len); 2031 ret = ipw2100_get_ordinal(priv, IPW_ORD_CURRENT_TX_RATE, &txrate, &len);
2032 if (ret) { 2032 if (ret) {
2033 IPW_DEBUG_INFO("failed querying ordinals at line %d\n", 2033 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
2034 __LINE__); 2034 __LINE__);
2035 return; 2035 return;
2036 } 2036 }
2037 2037
2038 len = sizeof(u32); 2038 len = sizeof(u32);
2039 ret = ipw2100_get_ordinal(priv, IPW_ORD_OUR_FREQ, &chan, &len); 2039 ret = ipw2100_get_ordinal(priv, IPW_ORD_OUR_FREQ, &chan, &len);
2040 if (ret) { 2040 if (ret) {
2041 IPW_DEBUG_INFO("failed querying ordinals at line %d\n", 2041 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
2042 __LINE__); 2042 __LINE__);
2043 return; 2043 return;
2044 } 2044 }
2045 len = ETH_ALEN; 2045 len = ETH_ALEN;
2046 ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID, &bssid, &len); 2046 ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID, &bssid, &len);
2047 if (ret) { 2047 if (ret) {
2048 IPW_DEBUG_INFO("failed querying ordinals at line %d\n", 2048 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
2049 __LINE__); 2049 __LINE__);
2050 return; 2050 return;
2051 } 2051 }
2052 memcpy(priv->ieee->bssid, bssid, ETH_ALEN); 2052 memcpy(priv->ieee->bssid, bssid, ETH_ALEN);
2053 2053
2054 switch (txrate) { 2054 switch (txrate) {
2055 case TX_RATE_1_MBIT: 2055 case TX_RATE_1_MBIT:
2056 txratename = "1Mbps"; 2056 txratename = "1Mbps";
2057 break; 2057 break;
2058 case TX_RATE_2_MBIT: 2058 case TX_RATE_2_MBIT:
2059 txratename = "2Mbsp"; 2059 txratename = "2Mbsp";
2060 break; 2060 break;
2061 case TX_RATE_5_5_MBIT: 2061 case TX_RATE_5_5_MBIT:
2062 txratename = "5.5Mbps"; 2062 txratename = "5.5Mbps";
2063 break; 2063 break;
2064 case TX_RATE_11_MBIT: 2064 case TX_RATE_11_MBIT:
2065 txratename = "11Mbps"; 2065 txratename = "11Mbps";
2066 break; 2066 break;
2067 default: 2067 default:
2068 IPW_DEBUG_INFO("Unknown rate: %d\n", txrate); 2068 IPW_DEBUG_INFO("Unknown rate: %d\n", txrate);
2069 txratename = "unknown rate"; 2069 txratename = "unknown rate";
2070 break; 2070 break;
2071 } 2071 }
2072 2072
2073 IPW_DEBUG_INFO("%s: Associated with '%s' at %s, channel %d (BSSID=%pM)\n", 2073 IPW_DEBUG_INFO("%s: Associated with '%s' at %s, channel %d (BSSID=%pM)\n",
2074 priv->net_dev->name, print_ssid(ssid, essid, essid_len), 2074 priv->net_dev->name, print_ssid(ssid, essid, essid_len),
2075 txratename, chan, bssid); 2075 txratename, chan, bssid);
2076 2076
2077 /* now we copy read ssid into dev */ 2077 /* now we copy read ssid into dev */
2078 if (!(priv->config & CFG_STATIC_ESSID)) { 2078 if (!(priv->config & CFG_STATIC_ESSID)) {
2079 priv->essid_len = min((u8) essid_len, (u8) IW_ESSID_MAX_SIZE); 2079 priv->essid_len = min((u8) essid_len, (u8) IW_ESSID_MAX_SIZE);
2080 memcpy(priv->essid, essid, priv->essid_len); 2080 memcpy(priv->essid, essid, priv->essid_len);
2081 } 2081 }
2082 priv->channel = chan; 2082 priv->channel = chan;
2083 memcpy(priv->bssid, bssid, ETH_ALEN); 2083 memcpy(priv->bssid, bssid, ETH_ALEN);
2084 2084
2085 priv->status |= STATUS_ASSOCIATING; 2085 priv->status |= STATUS_ASSOCIATING;
2086 priv->connect_start = get_seconds(); 2086 priv->connect_start = get_seconds();
2087 2087
2088 schedule_delayed_work(&priv->wx_event_work, HZ / 10); 2088 schedule_delayed_work(&priv->wx_event_work, HZ / 10);
2089 } 2089 }
2090 2090
2091 static int ipw2100_set_essid(struct ipw2100_priv *priv, char *essid, 2091 static int ipw2100_set_essid(struct ipw2100_priv *priv, char *essid,
2092 int length, int batch_mode) 2092 int length, int batch_mode)
2093 { 2093 {
2094 int ssid_len = min(length, IW_ESSID_MAX_SIZE); 2094 int ssid_len = min(length, IW_ESSID_MAX_SIZE);
2095 struct host_command cmd = { 2095 struct host_command cmd = {
2096 .host_command = SSID, 2096 .host_command = SSID,
2097 .host_command_sequence = 0, 2097 .host_command_sequence = 0,
2098 .host_command_length = ssid_len 2098 .host_command_length = ssid_len
2099 }; 2099 };
2100 int err; 2100 int err;
2101 DECLARE_SSID_BUF(ssid); 2101 DECLARE_SSID_BUF(ssid);
2102 2102
2103 IPW_DEBUG_HC("SSID: '%s'\n", print_ssid(ssid, essid, ssid_len)); 2103 IPW_DEBUG_HC("SSID: '%s'\n", print_ssid(ssid, essid, ssid_len));
2104 2104
2105 if (ssid_len) 2105 if (ssid_len)
2106 memcpy(cmd.host_command_parameters, essid, ssid_len); 2106 memcpy(cmd.host_command_parameters, essid, ssid_len);
2107 2107
2108 if (!batch_mode) { 2108 if (!batch_mode) {
2109 err = ipw2100_disable_adapter(priv); 2109 err = ipw2100_disable_adapter(priv);
2110 if (err) 2110 if (err)
2111 return err; 2111 return err;
2112 } 2112 }
2113 2113
2114 /* Bug in FW currently doesn't honor bit 0 in SET_SCAN_OPTIONS to 2114 /* Bug in FW currently doesn't honor bit 0 in SET_SCAN_OPTIONS to
2115 * disable auto association -- so we cheat by setting a bogus SSID */ 2115 * disable auto association -- so we cheat by setting a bogus SSID */
2116 if (!ssid_len && !(priv->config & CFG_ASSOCIATE)) { 2116 if (!ssid_len && !(priv->config & CFG_ASSOCIATE)) {
2117 int i; 2117 int i;
2118 u8 *bogus = (u8 *) cmd.host_command_parameters; 2118 u8 *bogus = (u8 *) cmd.host_command_parameters;
2119 for (i = 0; i < IW_ESSID_MAX_SIZE; i++) 2119 for (i = 0; i < IW_ESSID_MAX_SIZE; i++)
2120 bogus[i] = 0x18 + i; 2120 bogus[i] = 0x18 + i;
2121 cmd.host_command_length = IW_ESSID_MAX_SIZE; 2121 cmd.host_command_length = IW_ESSID_MAX_SIZE;
2122 } 2122 }
2123 2123
2124 /* NOTE: We always send the SSID command even if the provided ESSID is 2124 /* NOTE: We always send the SSID command even if the provided ESSID is
2125 * the same as what we currently think is set. */ 2125 * the same as what we currently think is set. */
2126 2126
2127 err = ipw2100_hw_send_command(priv, &cmd); 2127 err = ipw2100_hw_send_command(priv, &cmd);
2128 if (!err) { 2128 if (!err) {
2129 memset(priv->essid + ssid_len, 0, IW_ESSID_MAX_SIZE - ssid_len); 2129 memset(priv->essid + ssid_len, 0, IW_ESSID_MAX_SIZE - ssid_len);
2130 memcpy(priv->essid, essid, ssid_len); 2130 memcpy(priv->essid, essid, ssid_len);
2131 priv->essid_len = ssid_len; 2131 priv->essid_len = ssid_len;
2132 } 2132 }
2133 2133
2134 if (!batch_mode) { 2134 if (!batch_mode) {
2135 if (ipw2100_enable_adapter(priv)) 2135 if (ipw2100_enable_adapter(priv))
2136 err = -EIO; 2136 err = -EIO;
2137 } 2137 }
2138 2138
2139 return err; 2139 return err;
2140 } 2140 }
2141 2141
2142 static void isr_indicate_association_lost(struct ipw2100_priv *priv, u32 status) 2142 static void isr_indicate_association_lost(struct ipw2100_priv *priv, u32 status)
2143 { 2143 {
2144 DECLARE_SSID_BUF(ssid); 2144 DECLARE_SSID_BUF(ssid);
2145 2145
2146 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC, 2146 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
2147 "disassociated: '%s' %pM\n", 2147 "disassociated: '%s' %pM\n",
2148 print_ssid(ssid, priv->essid, priv->essid_len), 2148 print_ssid(ssid, priv->essid, priv->essid_len),
2149 priv->bssid); 2149 priv->bssid);
2150 2150
2151 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING); 2151 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
2152 2152
2153 if (priv->status & STATUS_STOPPING) { 2153 if (priv->status & STATUS_STOPPING) {
2154 IPW_DEBUG_INFO("Card is stopping itself, discard ASSN_LOST.\n"); 2154 IPW_DEBUG_INFO("Card is stopping itself, discard ASSN_LOST.\n");
2155 return; 2155 return;
2156 } 2156 }
2157 2157
2158 memset(priv->bssid, 0, ETH_ALEN); 2158 memset(priv->bssid, 0, ETH_ALEN);
2159 memset(priv->ieee->bssid, 0, ETH_ALEN); 2159 memset(priv->ieee->bssid, 0, ETH_ALEN);
2160 2160
2161 netif_carrier_off(priv->net_dev); 2161 netif_carrier_off(priv->net_dev);
2162 netif_stop_queue(priv->net_dev); 2162 netif_stop_queue(priv->net_dev);
2163 2163
2164 if (!(priv->status & STATUS_RUNNING)) 2164 if (!(priv->status & STATUS_RUNNING))
2165 return; 2165 return;
2166 2166
2167 if (priv->status & STATUS_SECURITY_UPDATED) 2167 if (priv->status & STATUS_SECURITY_UPDATED)
2168 schedule_delayed_work(&priv->security_work, 0); 2168 schedule_delayed_work(&priv->security_work, 0);
2169 2169
2170 schedule_delayed_work(&priv->wx_event_work, 0); 2170 schedule_delayed_work(&priv->wx_event_work, 0);
2171 } 2171 }
2172 2172
2173 static void isr_indicate_rf_kill(struct ipw2100_priv *priv, u32 status) 2173 static void isr_indicate_rf_kill(struct ipw2100_priv *priv, u32 status)
2174 { 2174 {
2175 IPW_DEBUG_INFO("%s: RF Kill state changed to radio OFF.\n", 2175 IPW_DEBUG_INFO("%s: RF Kill state changed to radio OFF.\n",
2176 priv->net_dev->name); 2176 priv->net_dev->name);
2177 2177
2178 /* RF_KILL is now enabled (else we wouldn't be here) */ 2178 /* RF_KILL is now enabled (else we wouldn't be here) */
2179 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true); 2179 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true);
2180 priv->status |= STATUS_RF_KILL_HW; 2180 priv->status |= STATUS_RF_KILL_HW;
2181 2181
2182 /* Make sure the RF Kill check timer is running */ 2182 /* Make sure the RF Kill check timer is running */
2183 priv->stop_rf_kill = 0; 2183 priv->stop_rf_kill = 0;
2184 cancel_delayed_work(&priv->rf_kill); 2184 cancel_delayed_work(&priv->rf_kill);
2185 schedule_delayed_work(&priv->rf_kill, round_jiffies_relative(HZ)); 2185 schedule_delayed_work(&priv->rf_kill, round_jiffies_relative(HZ));
2186 } 2186 }
2187 2187
2188 static void send_scan_event(void *data) 2188 static void send_scan_event(void *data)
2189 { 2189 {
2190 struct ipw2100_priv *priv = data; 2190 struct ipw2100_priv *priv = data;
2191 union iwreq_data wrqu; 2191 union iwreq_data wrqu;
2192 2192
2193 wrqu.data.length = 0; 2193 wrqu.data.length = 0;
2194 wrqu.data.flags = 0; 2194 wrqu.data.flags = 0;
2195 wireless_send_event(priv->net_dev, SIOCGIWSCAN, &wrqu, NULL); 2195 wireless_send_event(priv->net_dev, SIOCGIWSCAN, &wrqu, NULL);
2196 } 2196 }
2197 2197
2198 static void ipw2100_scan_event_later(struct work_struct *work) 2198 static void ipw2100_scan_event_later(struct work_struct *work)
2199 { 2199 {
2200 send_scan_event(container_of(work, struct ipw2100_priv, 2200 send_scan_event(container_of(work, struct ipw2100_priv,
2201 scan_event_later.work)); 2201 scan_event_later.work));
2202 } 2202 }
2203 2203
2204 static void ipw2100_scan_event_now(struct work_struct *work) 2204 static void ipw2100_scan_event_now(struct work_struct *work)
2205 { 2205 {
2206 send_scan_event(container_of(work, struct ipw2100_priv, 2206 send_scan_event(container_of(work, struct ipw2100_priv,
2207 scan_event_now)); 2207 scan_event_now));
2208 } 2208 }
2209 2209
2210 static void isr_scan_complete(struct ipw2100_priv *priv, u32 status) 2210 static void isr_scan_complete(struct ipw2100_priv *priv, u32 status)
2211 { 2211 {
2212 IPW_DEBUG_SCAN("scan complete\n"); 2212 IPW_DEBUG_SCAN("scan complete\n");
2213 /* Age the scan results... */ 2213 /* Age the scan results... */
2214 priv->ieee->scans++; 2214 priv->ieee->scans++;
2215 priv->status &= ~STATUS_SCANNING; 2215 priv->status &= ~STATUS_SCANNING;
2216 2216
2217 /* Only userspace-requested scan completion events go out immediately */ 2217 /* Only userspace-requested scan completion events go out immediately */
2218 if (!priv->user_requested_scan) { 2218 if (!priv->user_requested_scan) {
2219 if (!delayed_work_pending(&priv->scan_event_later)) 2219 if (!delayed_work_pending(&priv->scan_event_later))
2220 schedule_delayed_work(&priv->scan_event_later, 2220 schedule_delayed_work(&priv->scan_event_later,
2221 round_jiffies_relative(msecs_to_jiffies(4000))); 2221 round_jiffies_relative(msecs_to_jiffies(4000)));
2222 } else { 2222 } else {
2223 priv->user_requested_scan = 0; 2223 priv->user_requested_scan = 0;
2224 cancel_delayed_work(&priv->scan_event_later); 2224 cancel_delayed_work(&priv->scan_event_later);
2225 schedule_work(&priv->scan_event_now); 2225 schedule_work(&priv->scan_event_now);
2226 } 2226 }
2227 } 2227 }
2228 2228
2229 #ifdef CONFIG_IPW2100_DEBUG 2229 #ifdef CONFIG_IPW2100_DEBUG
2230 #define IPW2100_HANDLER(v, f) { v, f, # v } 2230 #define IPW2100_HANDLER(v, f) { v, f, # v }
2231 struct ipw2100_status_indicator { 2231 struct ipw2100_status_indicator {
2232 int status; 2232 int status;
2233 void (*cb) (struct ipw2100_priv * priv, u32 status); 2233 void (*cb) (struct ipw2100_priv * priv, u32 status);
2234 char *name; 2234 char *name;
2235 }; 2235 };
2236 #else 2236 #else
2237 #define IPW2100_HANDLER(v, f) { v, f } 2237 #define IPW2100_HANDLER(v, f) { v, f }
2238 struct ipw2100_status_indicator { 2238 struct ipw2100_status_indicator {
2239 int status; 2239 int status;
2240 void (*cb) (struct ipw2100_priv * priv, u32 status); 2240 void (*cb) (struct ipw2100_priv * priv, u32 status);
2241 }; 2241 };
2242 #endif /* CONFIG_IPW2100_DEBUG */ 2242 #endif /* CONFIG_IPW2100_DEBUG */
2243 2243
2244 static void isr_indicate_scanning(struct ipw2100_priv *priv, u32 status) 2244 static void isr_indicate_scanning(struct ipw2100_priv *priv, u32 status)
2245 { 2245 {
2246 IPW_DEBUG_SCAN("Scanning...\n"); 2246 IPW_DEBUG_SCAN("Scanning...\n");
2247 priv->status |= STATUS_SCANNING; 2247 priv->status |= STATUS_SCANNING;
2248 } 2248 }
2249 2249
2250 static const struct ipw2100_status_indicator status_handlers[] = { 2250 static const struct ipw2100_status_indicator status_handlers[] = {
2251 IPW2100_HANDLER(IPW_STATE_INITIALIZED, NULL), 2251 IPW2100_HANDLER(IPW_STATE_INITIALIZED, NULL),
2252 IPW2100_HANDLER(IPW_STATE_COUNTRY_FOUND, NULL), 2252 IPW2100_HANDLER(IPW_STATE_COUNTRY_FOUND, NULL),
2253 IPW2100_HANDLER(IPW_STATE_ASSOCIATED, isr_indicate_associated), 2253 IPW2100_HANDLER(IPW_STATE_ASSOCIATED, isr_indicate_associated),
2254 IPW2100_HANDLER(IPW_STATE_ASSN_LOST, isr_indicate_association_lost), 2254 IPW2100_HANDLER(IPW_STATE_ASSN_LOST, isr_indicate_association_lost),
2255 IPW2100_HANDLER(IPW_STATE_ASSN_CHANGED, NULL), 2255 IPW2100_HANDLER(IPW_STATE_ASSN_CHANGED, NULL),
2256 IPW2100_HANDLER(IPW_STATE_SCAN_COMPLETE, isr_scan_complete), 2256 IPW2100_HANDLER(IPW_STATE_SCAN_COMPLETE, isr_scan_complete),
2257 IPW2100_HANDLER(IPW_STATE_ENTERED_PSP, NULL), 2257 IPW2100_HANDLER(IPW_STATE_ENTERED_PSP, NULL),
2258 IPW2100_HANDLER(IPW_STATE_LEFT_PSP, NULL), 2258 IPW2100_HANDLER(IPW_STATE_LEFT_PSP, NULL),
2259 IPW2100_HANDLER(IPW_STATE_RF_KILL, isr_indicate_rf_kill), 2259 IPW2100_HANDLER(IPW_STATE_RF_KILL, isr_indicate_rf_kill),
2260 IPW2100_HANDLER(IPW_STATE_DISABLED, NULL), 2260 IPW2100_HANDLER(IPW_STATE_DISABLED, NULL),
2261 IPW2100_HANDLER(IPW_STATE_POWER_DOWN, NULL), 2261 IPW2100_HANDLER(IPW_STATE_POWER_DOWN, NULL),
2262 IPW2100_HANDLER(IPW_STATE_SCANNING, isr_indicate_scanning), 2262 IPW2100_HANDLER(IPW_STATE_SCANNING, isr_indicate_scanning),
2263 IPW2100_HANDLER(-1, NULL) 2263 IPW2100_HANDLER(-1, NULL)
2264 }; 2264 };
2265 2265
2266 static void isr_status_change(struct ipw2100_priv *priv, int status) 2266 static void isr_status_change(struct ipw2100_priv *priv, int status)
2267 { 2267 {
2268 int i; 2268 int i;
2269 2269
2270 if (status == IPW_STATE_SCANNING && 2270 if (status == IPW_STATE_SCANNING &&
2271 priv->status & STATUS_ASSOCIATED && 2271 priv->status & STATUS_ASSOCIATED &&
2272 !(priv->status & STATUS_SCANNING)) { 2272 !(priv->status & STATUS_SCANNING)) {
2273 IPW_DEBUG_INFO("Scan detected while associated, with " 2273 IPW_DEBUG_INFO("Scan detected while associated, with "
2274 "no scan request. Restarting firmware.\n"); 2274 "no scan request. Restarting firmware.\n");
2275 2275
2276 /* Wake up any sleeping jobs */ 2276 /* Wake up any sleeping jobs */
2277 schedule_reset(priv); 2277 schedule_reset(priv);
2278 } 2278 }
2279 2279
2280 for (i = 0; status_handlers[i].status != -1; i++) { 2280 for (i = 0; status_handlers[i].status != -1; i++) {
2281 if (status == status_handlers[i].status) { 2281 if (status == status_handlers[i].status) {
2282 IPW_DEBUG_NOTIF("Status change: %s\n", 2282 IPW_DEBUG_NOTIF("Status change: %s\n",
2283 status_handlers[i].name); 2283 status_handlers[i].name);
2284 if (status_handlers[i].cb) 2284 if (status_handlers[i].cb)
2285 status_handlers[i].cb(priv, status); 2285 status_handlers[i].cb(priv, status);
2286 priv->wstats.status = status; 2286 priv->wstats.status = status;
2287 return; 2287 return;
2288 } 2288 }
2289 } 2289 }
2290 2290
2291 IPW_DEBUG_NOTIF("unknown status received: %04x\n", status); 2291 IPW_DEBUG_NOTIF("unknown status received: %04x\n", status);
2292 } 2292 }
2293 2293
2294 static void isr_rx_complete_command(struct ipw2100_priv *priv, 2294 static void isr_rx_complete_command(struct ipw2100_priv *priv,
2295 struct ipw2100_cmd_header *cmd) 2295 struct ipw2100_cmd_header *cmd)
2296 { 2296 {
2297 #ifdef CONFIG_IPW2100_DEBUG 2297 #ifdef CONFIG_IPW2100_DEBUG
2298 if (cmd->host_command_reg < ARRAY_SIZE(command_types)) { 2298 if (cmd->host_command_reg < ARRAY_SIZE(command_types)) {
2299 IPW_DEBUG_HC("Command completed '%s (%d)'\n", 2299 IPW_DEBUG_HC("Command completed '%s (%d)'\n",
2300 command_types[cmd->host_command_reg], 2300 command_types[cmd->host_command_reg],
2301 cmd->host_command_reg); 2301 cmd->host_command_reg);
2302 } 2302 }
2303 #endif 2303 #endif
2304 if (cmd->host_command_reg == HOST_COMPLETE) 2304 if (cmd->host_command_reg == HOST_COMPLETE)
2305 priv->status |= STATUS_ENABLED; 2305 priv->status |= STATUS_ENABLED;
2306 2306
2307 if (cmd->host_command_reg == CARD_DISABLE) 2307 if (cmd->host_command_reg == CARD_DISABLE)
2308 priv->status &= ~STATUS_ENABLED; 2308 priv->status &= ~STATUS_ENABLED;
2309 2309
2310 priv->status &= ~STATUS_CMD_ACTIVE; 2310 priv->status &= ~STATUS_CMD_ACTIVE;
2311 2311
2312 wake_up_interruptible(&priv->wait_command_queue); 2312 wake_up_interruptible(&priv->wait_command_queue);
2313 } 2313 }
2314 2314
2315 #ifdef CONFIG_IPW2100_DEBUG 2315 #ifdef CONFIG_IPW2100_DEBUG
2316 static const char *frame_types[] = { 2316 static const char *frame_types[] = {
2317 "COMMAND_STATUS_VAL", 2317 "COMMAND_STATUS_VAL",
2318 "STATUS_CHANGE_VAL", 2318 "STATUS_CHANGE_VAL",
2319 "P80211_DATA_VAL", 2319 "P80211_DATA_VAL",
2320 "P8023_DATA_VAL", 2320 "P8023_DATA_VAL",
2321 "HOST_NOTIFICATION_VAL" 2321 "HOST_NOTIFICATION_VAL"
2322 }; 2322 };
2323 #endif 2323 #endif
2324 2324
2325 static int ipw2100_alloc_skb(struct ipw2100_priv *priv, 2325 static int ipw2100_alloc_skb(struct ipw2100_priv *priv,
2326 struct ipw2100_rx_packet *packet) 2326 struct ipw2100_rx_packet *packet)
2327 { 2327 {
2328 packet->skb = dev_alloc_skb(sizeof(struct ipw2100_rx)); 2328 packet->skb = dev_alloc_skb(sizeof(struct ipw2100_rx));
2329 if (!packet->skb) 2329 if (!packet->skb)
2330 return -ENOMEM; 2330 return -ENOMEM;
2331 2331
2332 packet->rxp = (struct ipw2100_rx *)packet->skb->data; 2332 packet->rxp = (struct ipw2100_rx *)packet->skb->data;
2333 packet->dma_addr = pci_map_single(priv->pci_dev, packet->skb->data, 2333 packet->dma_addr = pci_map_single(priv->pci_dev, packet->skb->data,
2334 sizeof(struct ipw2100_rx), 2334 sizeof(struct ipw2100_rx),
2335 PCI_DMA_FROMDEVICE); 2335 PCI_DMA_FROMDEVICE);
2336 /* NOTE: pci_map_single does not return an error code, and 0 is a valid 2336 /* NOTE: pci_map_single does not return an error code, and 0 is a valid
2337 * dma_addr */ 2337 * dma_addr */
2338 2338
2339 return 0; 2339 return 0;
2340 } 2340 }
2341 2341
2342 #define SEARCH_ERROR 0xffffffff 2342 #define SEARCH_ERROR 0xffffffff
2343 #define SEARCH_FAIL 0xfffffffe 2343 #define SEARCH_FAIL 0xfffffffe
2344 #define SEARCH_SUCCESS 0xfffffff0 2344 #define SEARCH_SUCCESS 0xfffffff0
2345 #define SEARCH_DISCARD 0 2345 #define SEARCH_DISCARD 0
2346 #define SEARCH_SNAPSHOT 1 2346 #define SEARCH_SNAPSHOT 1
2347 2347
2348 #define SNAPSHOT_ADDR(ofs) (priv->snapshot[((ofs) >> 12) & 0xff] + ((ofs) & 0xfff)) 2348 #define SNAPSHOT_ADDR(ofs) (priv->snapshot[((ofs) >> 12) & 0xff] + ((ofs) & 0xfff))
2349 static void ipw2100_snapshot_free(struct ipw2100_priv *priv) 2349 static void ipw2100_snapshot_free(struct ipw2100_priv *priv)
2350 { 2350 {
2351 int i; 2351 int i;
2352 if (!priv->snapshot[0]) 2352 if (!priv->snapshot[0])
2353 return; 2353 return;
2354 for (i = 0; i < 0x30; i++) 2354 for (i = 0; i < 0x30; i++)
2355 kfree(priv->snapshot[i]); 2355 kfree(priv->snapshot[i]);
2356 priv->snapshot[0] = NULL; 2356 priv->snapshot[0] = NULL;
2357 } 2357 }
2358 2358
2359 #ifdef IPW2100_DEBUG_C3 2359 #ifdef IPW2100_DEBUG_C3
2360 static int ipw2100_snapshot_alloc(struct ipw2100_priv *priv) 2360 static int ipw2100_snapshot_alloc(struct ipw2100_priv *priv)
2361 { 2361 {
2362 int i; 2362 int i;
2363 if (priv->snapshot[0]) 2363 if (priv->snapshot[0])
2364 return 1; 2364 return 1;
2365 for (i = 0; i < 0x30; i++) { 2365 for (i = 0; i < 0x30; i++) {
2366 priv->snapshot[i] = kmalloc(0x1000, GFP_ATOMIC); 2366 priv->snapshot[i] = kmalloc(0x1000, GFP_ATOMIC);
2367 if (!priv->snapshot[i]) { 2367 if (!priv->snapshot[i]) {
2368 IPW_DEBUG_INFO("%s: Error allocating snapshot " 2368 IPW_DEBUG_INFO("%s: Error allocating snapshot "
2369 "buffer %d\n", priv->net_dev->name, i); 2369 "buffer %d\n", priv->net_dev->name, i);
2370 while (i > 0) 2370 while (i > 0)
2371 kfree(priv->snapshot[--i]); 2371 kfree(priv->snapshot[--i]);
2372 priv->snapshot[0] = NULL; 2372 priv->snapshot[0] = NULL;
2373 return 0; 2373 return 0;
2374 } 2374 }
2375 } 2375 }
2376 2376
2377 return 1; 2377 return 1;
2378 } 2378 }
2379 2379
2380 static u32 ipw2100_match_buf(struct ipw2100_priv *priv, u8 * in_buf, 2380 static u32 ipw2100_match_buf(struct ipw2100_priv *priv, u8 * in_buf,
2381 size_t len, int mode) 2381 size_t len, int mode)
2382 { 2382 {
2383 u32 i, j; 2383 u32 i, j;
2384 u32 tmp; 2384 u32 tmp;
2385 u8 *s, *d; 2385 u8 *s, *d;
2386 u32 ret; 2386 u32 ret;
2387 2387
2388 s = in_buf; 2388 s = in_buf;
2389 if (mode == SEARCH_SNAPSHOT) { 2389 if (mode == SEARCH_SNAPSHOT) {
2390 if (!ipw2100_snapshot_alloc(priv)) 2390 if (!ipw2100_snapshot_alloc(priv))
2391 mode = SEARCH_DISCARD; 2391 mode = SEARCH_DISCARD;
2392 } 2392 }
2393 2393
2394 for (ret = SEARCH_FAIL, i = 0; i < 0x30000; i += 4) { 2394 for (ret = SEARCH_FAIL, i = 0; i < 0x30000; i += 4) {
2395 read_nic_dword(priv->net_dev, i, &tmp); 2395 read_nic_dword(priv->net_dev, i, &tmp);
2396 if (mode == SEARCH_SNAPSHOT) 2396 if (mode == SEARCH_SNAPSHOT)
2397 *(u32 *) SNAPSHOT_ADDR(i) = tmp; 2397 *(u32 *) SNAPSHOT_ADDR(i) = tmp;
2398 if (ret == SEARCH_FAIL) { 2398 if (ret == SEARCH_FAIL) {
2399 d = (u8 *) & tmp; 2399 d = (u8 *) & tmp;
2400 for (j = 0; j < 4; j++) { 2400 for (j = 0; j < 4; j++) {
2401 if (*s != *d) { 2401 if (*s != *d) {
2402 s = in_buf; 2402 s = in_buf;
2403 continue; 2403 continue;
2404 } 2404 }
2405 2405
2406 s++; 2406 s++;
2407 d++; 2407 d++;
2408 2408
2409 if ((s - in_buf) == len) 2409 if ((s - in_buf) == len)
2410 ret = (i + j) - len + 1; 2410 ret = (i + j) - len + 1;
2411 } 2411 }
2412 } else if (mode == SEARCH_DISCARD) 2412 } else if (mode == SEARCH_DISCARD)
2413 return ret; 2413 return ret;
2414 } 2414 }
2415 2415
2416 return ret; 2416 return ret;
2417 } 2417 }
2418 #endif 2418 #endif
2419 2419
2420 /* 2420 /*
2421 * 2421 *
2422 * 0) Disconnect the SKB from the firmware (just unmap) 2422 * 0) Disconnect the SKB from the firmware (just unmap)
2423 * 1) Pack the ETH header into the SKB 2423 * 1) Pack the ETH header into the SKB
2424 * 2) Pass the SKB to the network stack 2424 * 2) Pass the SKB to the network stack
2425 * 2425 *
2426 * When packet is provided by the firmware, it contains the following: 2426 * When packet is provided by the firmware, it contains the following:
2427 * 2427 *
2428 * . libipw_hdr 2428 * . libipw_hdr
2429 * . libipw_snap_hdr 2429 * . libipw_snap_hdr
2430 * 2430 *
2431 * The size of the constructed ethernet 2431 * The size of the constructed ethernet
2432 * 2432 *
2433 */ 2433 */
2434 #ifdef IPW2100_RX_DEBUG 2434 #ifdef IPW2100_RX_DEBUG
2435 static u8 packet_data[IPW_RX_NIC_BUFFER_LENGTH]; 2435 static u8 packet_data[IPW_RX_NIC_BUFFER_LENGTH];
2436 #endif 2436 #endif
2437 2437
2438 static void ipw2100_corruption_detected(struct ipw2100_priv *priv, int i) 2438 static void ipw2100_corruption_detected(struct ipw2100_priv *priv, int i)
2439 { 2439 {
2440 #ifdef IPW2100_DEBUG_C3 2440 #ifdef IPW2100_DEBUG_C3
2441 struct ipw2100_status *status = &priv->status_queue.drv[i]; 2441 struct ipw2100_status *status = &priv->status_queue.drv[i];
2442 u32 match, reg; 2442 u32 match, reg;
2443 int j; 2443 int j;
2444 #endif 2444 #endif
2445 2445
2446 IPW_DEBUG_INFO(": PCI latency error detected at 0x%04zX.\n", 2446 IPW_DEBUG_INFO(": PCI latency error detected at 0x%04zX.\n",
2447 i * sizeof(struct ipw2100_status)); 2447 i * sizeof(struct ipw2100_status));
2448 2448
2449 #ifdef IPW2100_DEBUG_C3 2449 #ifdef IPW2100_DEBUG_C3
2450 /* Halt the firmware so we can get a good image */ 2450 /* Halt the firmware so we can get a good image */
2451 write_register(priv->net_dev, IPW_REG_RESET_REG, 2451 write_register(priv->net_dev, IPW_REG_RESET_REG,
2452 IPW_AUX_HOST_RESET_REG_STOP_MASTER); 2452 IPW_AUX_HOST_RESET_REG_STOP_MASTER);
2453 j = 5; 2453 j = 5;
2454 do { 2454 do {
2455 udelay(IPW_WAIT_RESET_MASTER_ASSERT_COMPLETE_DELAY); 2455 udelay(IPW_WAIT_RESET_MASTER_ASSERT_COMPLETE_DELAY);
2456 read_register(priv->net_dev, IPW_REG_RESET_REG, &reg); 2456 read_register(priv->net_dev, IPW_REG_RESET_REG, &reg);
2457 2457
2458 if (reg & IPW_AUX_HOST_RESET_REG_MASTER_DISABLED) 2458 if (reg & IPW_AUX_HOST_RESET_REG_MASTER_DISABLED)
2459 break; 2459 break;
2460 } while (j--); 2460 } while (j--);
2461 2461
2462 match = ipw2100_match_buf(priv, (u8 *) status, 2462 match = ipw2100_match_buf(priv, (u8 *) status,
2463 sizeof(struct ipw2100_status), 2463 sizeof(struct ipw2100_status),
2464 SEARCH_SNAPSHOT); 2464 SEARCH_SNAPSHOT);
2465 if (match < SEARCH_SUCCESS) 2465 if (match < SEARCH_SUCCESS)
2466 IPW_DEBUG_INFO("%s: DMA status match in Firmware at " 2466 IPW_DEBUG_INFO("%s: DMA status match in Firmware at "
2467 "offset 0x%06X, length %d:\n", 2467 "offset 0x%06X, length %d:\n",
2468 priv->net_dev->name, match, 2468 priv->net_dev->name, match,
2469 sizeof(struct ipw2100_status)); 2469 sizeof(struct ipw2100_status));
2470 else 2470 else
2471 IPW_DEBUG_INFO("%s: No DMA status match in " 2471 IPW_DEBUG_INFO("%s: No DMA status match in "
2472 "Firmware.\n", priv->net_dev->name); 2472 "Firmware.\n", priv->net_dev->name);
2473 2473
2474 printk_buf((u8 *) priv->status_queue.drv, 2474 printk_buf((u8 *) priv->status_queue.drv,
2475 sizeof(struct ipw2100_status) * RX_QUEUE_LENGTH); 2475 sizeof(struct ipw2100_status) * RX_QUEUE_LENGTH);
2476 #endif 2476 #endif
2477 2477
2478 priv->fatal_error = IPW2100_ERR_C3_CORRUPTION; 2478 priv->fatal_error = IPW2100_ERR_C3_CORRUPTION;
2479 priv->net_dev->stats.rx_errors++; 2479 priv->net_dev->stats.rx_errors++;
2480 schedule_reset(priv); 2480 schedule_reset(priv);
2481 } 2481 }
2482 2482
2483 static void isr_rx(struct ipw2100_priv *priv, int i, 2483 static void isr_rx(struct ipw2100_priv *priv, int i,
2484 struct libipw_rx_stats *stats) 2484 struct libipw_rx_stats *stats)
2485 { 2485 {
2486 struct net_device *dev = priv->net_dev; 2486 struct net_device *dev = priv->net_dev;
2487 struct ipw2100_status *status = &priv->status_queue.drv[i]; 2487 struct ipw2100_status *status = &priv->status_queue.drv[i];
2488 struct ipw2100_rx_packet *packet = &priv->rx_buffers[i]; 2488 struct ipw2100_rx_packet *packet = &priv->rx_buffers[i];
2489 2489
2490 IPW_DEBUG_RX("Handler...\n"); 2490 IPW_DEBUG_RX("Handler...\n");
2491 2491
2492 if (unlikely(status->frame_size > skb_tailroom(packet->skb))) { 2492 if (unlikely(status->frame_size > skb_tailroom(packet->skb))) {
2493 IPW_DEBUG_INFO("%s: frame_size (%u) > skb_tailroom (%u)!" 2493 IPW_DEBUG_INFO("%s: frame_size (%u) > skb_tailroom (%u)!"
2494 " Dropping.\n", 2494 " Dropping.\n",
2495 dev->name, 2495 dev->name,
2496 status->frame_size, skb_tailroom(packet->skb)); 2496 status->frame_size, skb_tailroom(packet->skb));
2497 dev->stats.rx_errors++; 2497 dev->stats.rx_errors++;
2498 return; 2498 return;
2499 } 2499 }
2500 2500
2501 if (unlikely(!netif_running(dev))) { 2501 if (unlikely(!netif_running(dev))) {
2502 dev->stats.rx_errors++; 2502 dev->stats.rx_errors++;
2503 priv->wstats.discard.misc++; 2503 priv->wstats.discard.misc++;
2504 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n"); 2504 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
2505 return; 2505 return;
2506 } 2506 }
2507 2507
2508 if (unlikely(priv->ieee->iw_mode != IW_MODE_MONITOR && 2508 if (unlikely(priv->ieee->iw_mode != IW_MODE_MONITOR &&
2509 !(priv->status & STATUS_ASSOCIATED))) { 2509 !(priv->status & STATUS_ASSOCIATED))) {
2510 IPW_DEBUG_DROP("Dropping packet while not associated.\n"); 2510 IPW_DEBUG_DROP("Dropping packet while not associated.\n");
2511 priv->wstats.discard.misc++; 2511 priv->wstats.discard.misc++;
2512 return; 2512 return;
2513 } 2513 }
2514 2514
2515 pci_unmap_single(priv->pci_dev, 2515 pci_unmap_single(priv->pci_dev,
2516 packet->dma_addr, 2516 packet->dma_addr,
2517 sizeof(struct ipw2100_rx), PCI_DMA_FROMDEVICE); 2517 sizeof(struct ipw2100_rx), PCI_DMA_FROMDEVICE);
2518 2518
2519 skb_put(packet->skb, status->frame_size); 2519 skb_put(packet->skb, status->frame_size);
2520 2520
2521 #ifdef IPW2100_RX_DEBUG 2521 #ifdef IPW2100_RX_DEBUG
2522 /* Make a copy of the frame so we can dump it to the logs if 2522 /* Make a copy of the frame so we can dump it to the logs if
2523 * libipw_rx fails */ 2523 * libipw_rx fails */
2524 skb_copy_from_linear_data(packet->skb, packet_data, 2524 skb_copy_from_linear_data(packet->skb, packet_data,
2525 min_t(u32, status->frame_size, 2525 min_t(u32, status->frame_size,
2526 IPW_RX_NIC_BUFFER_LENGTH)); 2526 IPW_RX_NIC_BUFFER_LENGTH));
2527 #endif 2527 #endif
2528 2528
2529 if (!libipw_rx(priv->ieee, packet->skb, stats)) { 2529 if (!libipw_rx(priv->ieee, packet->skb, stats)) {
2530 #ifdef IPW2100_RX_DEBUG 2530 #ifdef IPW2100_RX_DEBUG
2531 IPW_DEBUG_DROP("%s: Non consumed packet:\n", 2531 IPW_DEBUG_DROP("%s: Non consumed packet:\n",
2532 dev->name); 2532 dev->name);
2533 printk_buf(IPW_DL_DROP, packet_data, status->frame_size); 2533 printk_buf(IPW_DL_DROP, packet_data, status->frame_size);
2534 #endif 2534 #endif
2535 dev->stats.rx_errors++; 2535 dev->stats.rx_errors++;
2536 2536
2537 /* libipw_rx failed, so it didn't free the SKB */ 2537 /* libipw_rx failed, so it didn't free the SKB */
2538 dev_kfree_skb_any(packet->skb); 2538 dev_kfree_skb_any(packet->skb);
2539 packet->skb = NULL; 2539 packet->skb = NULL;
2540 } 2540 }
2541 2541
2542 /* We need to allocate a new SKB and attach it to the RDB. */ 2542 /* We need to allocate a new SKB and attach it to the RDB. */
2543 if (unlikely(ipw2100_alloc_skb(priv, packet))) { 2543 if (unlikely(ipw2100_alloc_skb(priv, packet))) {
2544 printk(KERN_WARNING DRV_NAME ": " 2544 printk(KERN_WARNING DRV_NAME ": "
2545 "%s: Unable to allocate SKB onto RBD ring - disabling " 2545 "%s: Unable to allocate SKB onto RBD ring - disabling "
2546 "adapter.\n", dev->name); 2546 "adapter.\n", dev->name);
2547 /* TODO: schedule adapter shutdown */ 2547 /* TODO: schedule adapter shutdown */
2548 IPW_DEBUG_INFO("TODO: Shutdown adapter...\n"); 2548 IPW_DEBUG_INFO("TODO: Shutdown adapter...\n");
2549 } 2549 }
2550 2550
2551 /* Update the RDB entry */ 2551 /* Update the RDB entry */
2552 priv->rx_queue.drv[i].host_addr = packet->dma_addr; 2552 priv->rx_queue.drv[i].host_addr = packet->dma_addr;
2553 } 2553 }
2554 2554
2555 #ifdef CONFIG_IPW2100_MONITOR 2555 #ifdef CONFIG_IPW2100_MONITOR
2556 2556
2557 static void isr_rx_monitor(struct ipw2100_priv *priv, int i, 2557 static void isr_rx_monitor(struct ipw2100_priv *priv, int i,
2558 struct libipw_rx_stats *stats) 2558 struct libipw_rx_stats *stats)
2559 { 2559 {
2560 struct net_device *dev = priv->net_dev; 2560 struct net_device *dev = priv->net_dev;
2561 struct ipw2100_status *status = &priv->status_queue.drv[i]; 2561 struct ipw2100_status *status = &priv->status_queue.drv[i];
2562 struct ipw2100_rx_packet *packet = &priv->rx_buffers[i]; 2562 struct ipw2100_rx_packet *packet = &priv->rx_buffers[i];
2563 2563
2564 /* Magic struct that slots into the radiotap header -- no reason 2564 /* Magic struct that slots into the radiotap header -- no reason
2565 * to build this manually element by element, we can write it much 2565 * to build this manually element by element, we can write it much
2566 * more efficiently than we can parse it. ORDER MATTERS HERE */ 2566 * more efficiently than we can parse it. ORDER MATTERS HERE */
2567 struct ipw_rt_hdr { 2567 struct ipw_rt_hdr {
2568 struct ieee80211_radiotap_header rt_hdr; 2568 struct ieee80211_radiotap_header rt_hdr;
2569 s8 rt_dbmsignal; /* signal in dbM, kluged to signed */ 2569 s8 rt_dbmsignal; /* signal in dbM, kluged to signed */
2570 } *ipw_rt; 2570 } *ipw_rt;
2571 2571
2572 IPW_DEBUG_RX("Handler...\n"); 2572 IPW_DEBUG_RX("Handler...\n");
2573 2573
2574 if (unlikely(status->frame_size > skb_tailroom(packet->skb) - 2574 if (unlikely(status->frame_size > skb_tailroom(packet->skb) -
2575 sizeof(struct ipw_rt_hdr))) { 2575 sizeof(struct ipw_rt_hdr))) {
2576 IPW_DEBUG_INFO("%s: frame_size (%u) > skb_tailroom (%u)!" 2576 IPW_DEBUG_INFO("%s: frame_size (%u) > skb_tailroom (%u)!"
2577 " Dropping.\n", 2577 " Dropping.\n",
2578 dev->name, 2578 dev->name,
2579 status->frame_size, 2579 status->frame_size,
2580 skb_tailroom(packet->skb)); 2580 skb_tailroom(packet->skb));
2581 dev->stats.rx_errors++; 2581 dev->stats.rx_errors++;
2582 return; 2582 return;
2583 } 2583 }
2584 2584
2585 if (unlikely(!netif_running(dev))) { 2585 if (unlikely(!netif_running(dev))) {
2586 dev->stats.rx_errors++; 2586 dev->stats.rx_errors++;
2587 priv->wstats.discard.misc++; 2587 priv->wstats.discard.misc++;
2588 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n"); 2588 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
2589 return; 2589 return;
2590 } 2590 }
2591 2591
2592 if (unlikely(priv->config & CFG_CRC_CHECK && 2592 if (unlikely(priv->config & CFG_CRC_CHECK &&
2593 status->flags & IPW_STATUS_FLAG_CRC_ERROR)) { 2593 status->flags & IPW_STATUS_FLAG_CRC_ERROR)) {
2594 IPW_DEBUG_RX("CRC error in packet. Dropping.\n"); 2594 IPW_DEBUG_RX("CRC error in packet. Dropping.\n");
2595 dev->stats.rx_errors++; 2595 dev->stats.rx_errors++;
2596 return; 2596 return;
2597 } 2597 }
2598 2598
2599 pci_unmap_single(priv->pci_dev, packet->dma_addr, 2599 pci_unmap_single(priv->pci_dev, packet->dma_addr,
2600 sizeof(struct ipw2100_rx), PCI_DMA_FROMDEVICE); 2600 sizeof(struct ipw2100_rx), PCI_DMA_FROMDEVICE);
2601 memmove(packet->skb->data + sizeof(struct ipw_rt_hdr), 2601 memmove(packet->skb->data + sizeof(struct ipw_rt_hdr),
2602 packet->skb->data, status->frame_size); 2602 packet->skb->data, status->frame_size);
2603 2603
2604 ipw_rt = (struct ipw_rt_hdr *) packet->skb->data; 2604 ipw_rt = (struct ipw_rt_hdr *) packet->skb->data;
2605 2605
2606 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION; 2606 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
2607 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */ 2607 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
2608 ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(struct ipw_rt_hdr)); /* total hdr+data */ 2608 ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(struct ipw_rt_hdr)); /* total hdr+data */
2609 2609
2610 ipw_rt->rt_hdr.it_present = cpu_to_le32(1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL); 2610 ipw_rt->rt_hdr.it_present = cpu_to_le32(1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL);
2611 2611
2612 ipw_rt->rt_dbmsignal = status->rssi + IPW2100_RSSI_TO_DBM; 2612 ipw_rt->rt_dbmsignal = status->rssi + IPW2100_RSSI_TO_DBM;
2613 2613
2614 skb_put(packet->skb, status->frame_size + sizeof(struct ipw_rt_hdr)); 2614 skb_put(packet->skb, status->frame_size + sizeof(struct ipw_rt_hdr));
2615 2615
2616 if (!libipw_rx(priv->ieee, packet->skb, stats)) { 2616 if (!libipw_rx(priv->ieee, packet->skb, stats)) {
2617 dev->stats.rx_errors++; 2617 dev->stats.rx_errors++;
2618 2618
2619 /* libipw_rx failed, so it didn't free the SKB */ 2619 /* libipw_rx failed, so it didn't free the SKB */
2620 dev_kfree_skb_any(packet->skb); 2620 dev_kfree_skb_any(packet->skb);
2621 packet->skb = NULL; 2621 packet->skb = NULL;
2622 } 2622 }
2623 2623
2624 /* We need to allocate a new SKB and attach it to the RDB. */ 2624 /* We need to allocate a new SKB and attach it to the RDB. */
2625 if (unlikely(ipw2100_alloc_skb(priv, packet))) { 2625 if (unlikely(ipw2100_alloc_skb(priv, packet))) {
2626 IPW_DEBUG_WARNING( 2626 IPW_DEBUG_WARNING(
2627 "%s: Unable to allocate SKB onto RBD ring - disabling " 2627 "%s: Unable to allocate SKB onto RBD ring - disabling "
2628 "adapter.\n", dev->name); 2628 "adapter.\n", dev->name);
2629 /* TODO: schedule adapter shutdown */ 2629 /* TODO: schedule adapter shutdown */
2630 IPW_DEBUG_INFO("TODO: Shutdown adapter...\n"); 2630 IPW_DEBUG_INFO("TODO: Shutdown adapter...\n");
2631 } 2631 }
2632 2632
2633 /* Update the RDB entry */ 2633 /* Update the RDB entry */
2634 priv->rx_queue.drv[i].host_addr = packet->dma_addr; 2634 priv->rx_queue.drv[i].host_addr = packet->dma_addr;
2635 } 2635 }
2636 2636
2637 #endif 2637 #endif
2638 2638
2639 static int ipw2100_corruption_check(struct ipw2100_priv *priv, int i) 2639 static int ipw2100_corruption_check(struct ipw2100_priv *priv, int i)
2640 { 2640 {
2641 struct ipw2100_status *status = &priv->status_queue.drv[i]; 2641 struct ipw2100_status *status = &priv->status_queue.drv[i];
2642 struct ipw2100_rx *u = priv->rx_buffers[i].rxp; 2642 struct ipw2100_rx *u = priv->rx_buffers[i].rxp;
2643 u16 frame_type = status->status_fields & STATUS_TYPE_MASK; 2643 u16 frame_type = status->status_fields & STATUS_TYPE_MASK;
2644 2644
2645 switch (frame_type) { 2645 switch (frame_type) {
2646 case COMMAND_STATUS_VAL: 2646 case COMMAND_STATUS_VAL:
2647 return (status->frame_size != sizeof(u->rx_data.command)); 2647 return (status->frame_size != sizeof(u->rx_data.command));
2648 case STATUS_CHANGE_VAL: 2648 case STATUS_CHANGE_VAL:
2649 return (status->frame_size != sizeof(u->rx_data.status)); 2649 return (status->frame_size != sizeof(u->rx_data.status));
2650 case HOST_NOTIFICATION_VAL: 2650 case HOST_NOTIFICATION_VAL:
2651 return (status->frame_size < sizeof(u->rx_data.notification)); 2651 return (status->frame_size < sizeof(u->rx_data.notification));
2652 case P80211_DATA_VAL: 2652 case P80211_DATA_VAL:
2653 case P8023_DATA_VAL: 2653 case P8023_DATA_VAL:
2654 #ifdef CONFIG_IPW2100_MONITOR 2654 #ifdef CONFIG_IPW2100_MONITOR
2655 return 0; 2655 return 0;
2656 #else 2656 #else
2657 switch (WLAN_FC_GET_TYPE(le16_to_cpu(u->rx_data.header.frame_ctl))) { 2657 switch (WLAN_FC_GET_TYPE(le16_to_cpu(u->rx_data.header.frame_ctl))) {
2658 case IEEE80211_FTYPE_MGMT: 2658 case IEEE80211_FTYPE_MGMT:
2659 case IEEE80211_FTYPE_CTL: 2659 case IEEE80211_FTYPE_CTL:
2660 return 0; 2660 return 0;
2661 case IEEE80211_FTYPE_DATA: 2661 case IEEE80211_FTYPE_DATA:
2662 return (status->frame_size > 2662 return (status->frame_size >
2663 IPW_MAX_802_11_PAYLOAD_LENGTH); 2663 IPW_MAX_802_11_PAYLOAD_LENGTH);
2664 } 2664 }
2665 #endif 2665 #endif
2666 } 2666 }
2667 2667
2668 return 1; 2668 return 1;
2669 } 2669 }
2670 2670
2671 /* 2671 /*
2672 * ipw2100 interrupts are disabled at this point, and the ISR 2672 * ipw2100 interrupts are disabled at this point, and the ISR
2673 * is the only code that calls this method. So, we do not need 2673 * is the only code that calls this method. So, we do not need
2674 * to play with any locks. 2674 * to play with any locks.
2675 * 2675 *
2676 * RX Queue works as follows: 2676 * RX Queue works as follows:
2677 * 2677 *
2678 * Read index - firmware places packet in entry identified by the 2678 * Read index - firmware places packet in entry identified by the
2679 * Read index and advances Read index. In this manner, 2679 * Read index and advances Read index. In this manner,
2680 * Read index will always point to the next packet to 2680 * Read index will always point to the next packet to
2681 * be filled--but not yet valid. 2681 * be filled--but not yet valid.
2682 * 2682 *
2683 * Write index - driver fills this entry with an unused RBD entry. 2683 * Write index - driver fills this entry with an unused RBD entry.
2684 * This entry has not filled by the firmware yet. 2684 * This entry has not filled by the firmware yet.
2685 * 2685 *
2686 * In between the W and R indexes are the RBDs that have been received 2686 * In between the W and R indexes are the RBDs that have been received
2687 * but not yet processed. 2687 * but not yet processed.
2688 * 2688 *
2689 * The process of handling packets will start at WRITE + 1 and advance 2689 * The process of handling packets will start at WRITE + 1 and advance
2690 * until it reaches the READ index. 2690 * until it reaches the READ index.
2691 * 2691 *
2692 * The WRITE index is cached in the variable 'priv->rx_queue.next'. 2692 * The WRITE index is cached in the variable 'priv->rx_queue.next'.
2693 * 2693 *
2694 */ 2694 */
2695 static void __ipw2100_rx_process(struct ipw2100_priv *priv) 2695 static void __ipw2100_rx_process(struct ipw2100_priv *priv)
2696 { 2696 {
2697 struct ipw2100_bd_queue *rxq = &priv->rx_queue; 2697 struct ipw2100_bd_queue *rxq = &priv->rx_queue;
2698 struct ipw2100_status_queue *sq = &priv->status_queue; 2698 struct ipw2100_status_queue *sq = &priv->status_queue;
2699 struct ipw2100_rx_packet *packet; 2699 struct ipw2100_rx_packet *packet;
2700 u16 frame_type; 2700 u16 frame_type;
2701 u32 r, w, i, s; 2701 u32 r, w, i, s;
2702 struct ipw2100_rx *u; 2702 struct ipw2100_rx *u;
2703 struct libipw_rx_stats stats = { 2703 struct libipw_rx_stats stats = {
2704 .mac_time = jiffies, 2704 .mac_time = jiffies,
2705 }; 2705 };
2706 2706
2707 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_RX_READ_INDEX, &r); 2707 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_RX_READ_INDEX, &r);
2708 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_RX_WRITE_INDEX, &w); 2708 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_RX_WRITE_INDEX, &w);
2709 2709
2710 if (r >= rxq->entries) { 2710 if (r >= rxq->entries) {
2711 IPW_DEBUG_RX("exit - bad read index\n"); 2711 IPW_DEBUG_RX("exit - bad read index\n");
2712 return; 2712 return;
2713 } 2713 }
2714 2714
2715 i = (rxq->next + 1) % rxq->entries; 2715 i = (rxq->next + 1) % rxq->entries;
2716 s = i; 2716 s = i;
2717 while (i != r) { 2717 while (i != r) {
2718 /* IPW_DEBUG_RX("r = %d : w = %d : processing = %d\n", 2718 /* IPW_DEBUG_RX("r = %d : w = %d : processing = %d\n",
2719 r, rxq->next, i); */ 2719 r, rxq->next, i); */
2720 2720
2721 packet = &priv->rx_buffers[i]; 2721 packet = &priv->rx_buffers[i];
2722 2722
2723 /* Sync the DMA for the RX buffer so CPU is sure to get 2723 /* Sync the DMA for the RX buffer so CPU is sure to get
2724 * the correct values */ 2724 * the correct values */
2725 pci_dma_sync_single_for_cpu(priv->pci_dev, packet->dma_addr, 2725 pci_dma_sync_single_for_cpu(priv->pci_dev, packet->dma_addr,
2726 sizeof(struct ipw2100_rx), 2726 sizeof(struct ipw2100_rx),
2727 PCI_DMA_FROMDEVICE); 2727 PCI_DMA_FROMDEVICE);
2728 2728
2729 if (unlikely(ipw2100_corruption_check(priv, i))) { 2729 if (unlikely(ipw2100_corruption_check(priv, i))) {
2730 ipw2100_corruption_detected(priv, i); 2730 ipw2100_corruption_detected(priv, i);
2731 goto increment; 2731 goto increment;
2732 } 2732 }
2733 2733
2734 u = packet->rxp; 2734 u = packet->rxp;
2735 frame_type = sq->drv[i].status_fields & STATUS_TYPE_MASK; 2735 frame_type = sq->drv[i].status_fields & STATUS_TYPE_MASK;
2736 stats.rssi = sq->drv[i].rssi + IPW2100_RSSI_TO_DBM; 2736 stats.rssi = sq->drv[i].rssi + IPW2100_RSSI_TO_DBM;
2737 stats.len = sq->drv[i].frame_size; 2737 stats.len = sq->drv[i].frame_size;
2738 2738
2739 stats.mask = 0; 2739 stats.mask = 0;
2740 if (stats.rssi != 0) 2740 if (stats.rssi != 0)
2741 stats.mask |= LIBIPW_STATMASK_RSSI; 2741 stats.mask |= LIBIPW_STATMASK_RSSI;
2742 stats.freq = LIBIPW_24GHZ_BAND; 2742 stats.freq = LIBIPW_24GHZ_BAND;
2743 2743
2744 IPW_DEBUG_RX("%s: '%s' frame type received (%d).\n", 2744 IPW_DEBUG_RX("%s: '%s' frame type received (%d).\n",
2745 priv->net_dev->name, frame_types[frame_type], 2745 priv->net_dev->name, frame_types[frame_type],
2746 stats.len); 2746 stats.len);
2747 2747
2748 switch (frame_type) { 2748 switch (frame_type) {
2749 case COMMAND_STATUS_VAL: 2749 case COMMAND_STATUS_VAL:
2750 /* Reset Rx watchdog */ 2750 /* Reset Rx watchdog */
2751 isr_rx_complete_command(priv, &u->rx_data.command); 2751 isr_rx_complete_command(priv, &u->rx_data.command);
2752 break; 2752 break;
2753 2753
2754 case STATUS_CHANGE_VAL: 2754 case STATUS_CHANGE_VAL:
2755 isr_status_change(priv, u->rx_data.status); 2755 isr_status_change(priv, u->rx_data.status);
2756 break; 2756 break;
2757 2757
2758 case P80211_DATA_VAL: 2758 case P80211_DATA_VAL:
2759 case P8023_DATA_VAL: 2759 case P8023_DATA_VAL:
2760 #ifdef CONFIG_IPW2100_MONITOR 2760 #ifdef CONFIG_IPW2100_MONITOR
2761 if (priv->ieee->iw_mode == IW_MODE_MONITOR) { 2761 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
2762 isr_rx_monitor(priv, i, &stats); 2762 isr_rx_monitor(priv, i, &stats);
2763 break; 2763 break;
2764 } 2764 }
2765 #endif 2765 #endif
2766 if (stats.len < sizeof(struct libipw_hdr_3addr)) 2766 if (stats.len < sizeof(struct libipw_hdr_3addr))
2767 break; 2767 break;
2768 switch (WLAN_FC_GET_TYPE(le16_to_cpu(u->rx_data.header.frame_ctl))) { 2768 switch (WLAN_FC_GET_TYPE(le16_to_cpu(u->rx_data.header.frame_ctl))) {
2769 case IEEE80211_FTYPE_MGMT: 2769 case IEEE80211_FTYPE_MGMT:
2770 libipw_rx_mgt(priv->ieee, 2770 libipw_rx_mgt(priv->ieee,
2771 &u->rx_data.header, &stats); 2771 &u->rx_data.header, &stats);
2772 break; 2772 break;
2773 2773
2774 case IEEE80211_FTYPE_CTL: 2774 case IEEE80211_FTYPE_CTL:
2775 break; 2775 break;
2776 2776
2777 case IEEE80211_FTYPE_DATA: 2777 case IEEE80211_FTYPE_DATA:
2778 isr_rx(priv, i, &stats); 2778 isr_rx(priv, i, &stats);
2779 break; 2779 break;
2780 2780
2781 } 2781 }
2782 break; 2782 break;
2783 } 2783 }
2784 2784
2785 increment: 2785 increment:
2786 /* clear status field associated with this RBD */ 2786 /* clear status field associated with this RBD */
2787 rxq->drv[i].status.info.field = 0; 2787 rxq->drv[i].status.info.field = 0;
2788 2788
2789 i = (i + 1) % rxq->entries; 2789 i = (i + 1) % rxq->entries;
2790 } 2790 }
2791 2791
2792 if (i != s) { 2792 if (i != s) {
2793 /* backtrack one entry, wrapping to end if at 0 */ 2793 /* backtrack one entry, wrapping to end if at 0 */
2794 rxq->next = (i ? i : rxq->entries) - 1; 2794 rxq->next = (i ? i : rxq->entries) - 1;
2795 2795
2796 write_register(priv->net_dev, 2796 write_register(priv->net_dev,
2797 IPW_MEM_HOST_SHARED_RX_WRITE_INDEX, rxq->next); 2797 IPW_MEM_HOST_SHARED_RX_WRITE_INDEX, rxq->next);
2798 } 2798 }
2799 } 2799 }
2800 2800
2801 /* 2801 /*
2802 * __ipw2100_tx_process 2802 * __ipw2100_tx_process
2803 * 2803 *
2804 * This routine will determine whether the next packet on 2804 * This routine will determine whether the next packet on
2805 * the fw_pend_list has been processed by the firmware yet. 2805 * the fw_pend_list has been processed by the firmware yet.
2806 * 2806 *
2807 * If not, then it does nothing and returns. 2807 * If not, then it does nothing and returns.
2808 * 2808 *
2809 * If so, then it removes the item from the fw_pend_list, frees 2809 * If so, then it removes the item from the fw_pend_list, frees
2810 * any associated storage, and places the item back on the 2810 * any associated storage, and places the item back on the
2811 * free list of its source (either msg_free_list or tx_free_list) 2811 * free list of its source (either msg_free_list or tx_free_list)
2812 * 2812 *
2813 * TX Queue works as follows: 2813 * TX Queue works as follows:
2814 * 2814 *
2815 * Read index - points to the next TBD that the firmware will 2815 * Read index - points to the next TBD that the firmware will
2816 * process. The firmware will read the data, and once 2816 * process. The firmware will read the data, and once
2817 * done processing, it will advance the Read index. 2817 * done processing, it will advance the Read index.
2818 * 2818 *
2819 * Write index - driver fills this entry with an constructed TBD 2819 * Write index - driver fills this entry with an constructed TBD
2820 * entry. The Write index is not advanced until the 2820 * entry. The Write index is not advanced until the
2821 * packet has been configured. 2821 * packet has been configured.
2822 * 2822 *
2823 * In between the W and R indexes are the TBDs that have NOT been 2823 * In between the W and R indexes are the TBDs that have NOT been
2824 * processed. Lagging behind the R index are packets that have 2824 * processed. Lagging behind the R index are packets that have
2825 * been processed but have not been freed by the driver. 2825 * been processed but have not been freed by the driver.
2826 * 2826 *
2827 * In order to free old storage, an internal index will be maintained 2827 * In order to free old storage, an internal index will be maintained
2828 * that points to the next packet to be freed. When all used 2828 * that points to the next packet to be freed. When all used
2829 * packets have been freed, the oldest index will be the same as the 2829 * packets have been freed, the oldest index will be the same as the
2830 * firmware's read index. 2830 * firmware's read index.
2831 * 2831 *
2832 * The OLDEST index is cached in the variable 'priv->tx_queue.oldest' 2832 * The OLDEST index is cached in the variable 'priv->tx_queue.oldest'
2833 * 2833 *
2834 * Because the TBD structure can not contain arbitrary data, the 2834 * Because the TBD structure can not contain arbitrary data, the
2835 * driver must keep an internal queue of cached allocations such that 2835 * driver must keep an internal queue of cached allocations such that
2836 * it can put that data back into the tx_free_list and msg_free_list 2836 * it can put that data back into the tx_free_list and msg_free_list
2837 * for use by future command and data packets. 2837 * for use by future command and data packets.
2838 * 2838 *
2839 */ 2839 */
2840 static int __ipw2100_tx_process(struct ipw2100_priv *priv) 2840 static int __ipw2100_tx_process(struct ipw2100_priv *priv)
2841 { 2841 {
2842 struct ipw2100_bd_queue *txq = &priv->tx_queue; 2842 struct ipw2100_bd_queue *txq = &priv->tx_queue;
2843 struct ipw2100_bd *tbd; 2843 struct ipw2100_bd *tbd;
2844 struct list_head *element; 2844 struct list_head *element;
2845 struct ipw2100_tx_packet *packet; 2845 struct ipw2100_tx_packet *packet;
2846 int descriptors_used; 2846 int descriptors_used;
2847 int e, i; 2847 int e, i;
2848 u32 r, w, frag_num = 0; 2848 u32 r, w, frag_num = 0;
2849 2849
2850 if (list_empty(&priv->fw_pend_list)) 2850 if (list_empty(&priv->fw_pend_list))
2851 return 0; 2851 return 0;
2852 2852
2853 element = priv->fw_pend_list.next; 2853 element = priv->fw_pend_list.next;
2854 2854
2855 packet = list_entry(element, struct ipw2100_tx_packet, list); 2855 packet = list_entry(element, struct ipw2100_tx_packet, list);
2856 tbd = &txq->drv[packet->index]; 2856 tbd = &txq->drv[packet->index];
2857 2857
2858 /* Determine how many TBD entries must be finished... */ 2858 /* Determine how many TBD entries must be finished... */
2859 switch (packet->type) { 2859 switch (packet->type) {
2860 case COMMAND: 2860 case COMMAND:
2861 /* COMMAND uses only one slot; don't advance */ 2861 /* COMMAND uses only one slot; don't advance */
2862 descriptors_used = 1; 2862 descriptors_used = 1;
2863 e = txq->oldest; 2863 e = txq->oldest;
2864 break; 2864 break;
2865 2865
2866 case DATA: 2866 case DATA:
2867 /* DATA uses two slots; advance and loop position. */ 2867 /* DATA uses two slots; advance and loop position. */
2868 descriptors_used = tbd->num_fragments; 2868 descriptors_used = tbd->num_fragments;
2869 frag_num = tbd->num_fragments - 1; 2869 frag_num = tbd->num_fragments - 1;
2870 e = txq->oldest + frag_num; 2870 e = txq->oldest + frag_num;
2871 e %= txq->entries; 2871 e %= txq->entries;
2872 break; 2872 break;
2873 2873
2874 default: 2874 default:
2875 printk(KERN_WARNING DRV_NAME ": %s: Bad fw_pend_list entry!\n", 2875 printk(KERN_WARNING DRV_NAME ": %s: Bad fw_pend_list entry!\n",
2876 priv->net_dev->name); 2876 priv->net_dev->name);
2877 return 0; 2877 return 0;
2878 } 2878 }
2879 2879
2880 /* if the last TBD is not done by NIC yet, then packet is 2880 /* if the last TBD is not done by NIC yet, then packet is
2881 * not ready to be released. 2881 * not ready to be released.
2882 * 2882 *
2883 */ 2883 */
2884 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_TX_QUEUE_READ_INDEX, 2884 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_TX_QUEUE_READ_INDEX,
2885 &r); 2885 &r);
2886 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX, 2886 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX,
2887 &w); 2887 &w);
2888 if (w != txq->next) 2888 if (w != txq->next)
2889 printk(KERN_WARNING DRV_NAME ": %s: write index mismatch\n", 2889 printk(KERN_WARNING DRV_NAME ": %s: write index mismatch\n",
2890 priv->net_dev->name); 2890 priv->net_dev->name);
2891 2891
2892 /* 2892 /*
2893 * txq->next is the index of the last packet written txq->oldest is 2893 * txq->next is the index of the last packet written txq->oldest is
2894 * the index of the r is the index of the next packet to be read by 2894 * the index of the r is the index of the next packet to be read by
2895 * firmware 2895 * firmware
2896 */ 2896 */
2897 2897
2898 /* 2898 /*
2899 * Quick graphic to help you visualize the following 2899 * Quick graphic to help you visualize the following
2900 * if / else statement 2900 * if / else statement
2901 * 2901 *
2902 * ===>| s---->|=============== 2902 * ===>| s---->|===============
2903 * e>| 2903 * e>|
2904 * | a | b | c | d | e | f | g | h | i | j | k | l 2904 * | a | b | c | d | e | f | g | h | i | j | k | l
2905 * r---->| 2905 * r---->|
2906 * w 2906 * w
2907 * 2907 *
2908 * w - updated by driver 2908 * w - updated by driver
2909 * r - updated by firmware 2909 * r - updated by firmware
2910 * s - start of oldest BD entry (txq->oldest) 2910 * s - start of oldest BD entry (txq->oldest)
2911 * e - end of oldest BD entry 2911 * e - end of oldest BD entry
2912 * 2912 *
2913 */ 2913 */
2914 if (!((r <= w && (e < r || e >= w)) || (e < r && e >= w))) { 2914 if (!((r <= w && (e < r || e >= w)) || (e < r && e >= w))) {
2915 IPW_DEBUG_TX("exit - no processed packets ready to release.\n"); 2915 IPW_DEBUG_TX("exit - no processed packets ready to release.\n");
2916 return 0; 2916 return 0;
2917 } 2917 }
2918 2918
2919 list_del(element); 2919 list_del(element);
2920 DEC_STAT(&priv->fw_pend_stat); 2920 DEC_STAT(&priv->fw_pend_stat);
2921 2921
2922 #ifdef CONFIG_IPW2100_DEBUG 2922 #ifdef CONFIG_IPW2100_DEBUG
2923 { 2923 {
2924 i = txq->oldest; 2924 i = txq->oldest;
2925 IPW_DEBUG_TX("TX%d V=%p P=%04X T=%04X L=%d\n", i, 2925 IPW_DEBUG_TX("TX%d V=%p P=%04X T=%04X L=%d\n", i,
2926 &txq->drv[i], 2926 &txq->drv[i],
2927 (u32) (txq->nic + i * sizeof(struct ipw2100_bd)), 2927 (u32) (txq->nic + i * sizeof(struct ipw2100_bd)),
2928 txq->drv[i].host_addr, txq->drv[i].buf_length); 2928 txq->drv[i].host_addr, txq->drv[i].buf_length);
2929 2929
2930 if (packet->type == DATA) { 2930 if (packet->type == DATA) {
2931 i = (i + 1) % txq->entries; 2931 i = (i + 1) % txq->entries;
2932 2932
2933 IPW_DEBUG_TX("TX%d V=%p P=%04X T=%04X L=%d\n", i, 2933 IPW_DEBUG_TX("TX%d V=%p P=%04X T=%04X L=%d\n", i,
2934 &txq->drv[i], 2934 &txq->drv[i],
2935 (u32) (txq->nic + i * 2935 (u32) (txq->nic + i *
2936 sizeof(struct ipw2100_bd)), 2936 sizeof(struct ipw2100_bd)),
2937 (u32) txq->drv[i].host_addr, 2937 (u32) txq->drv[i].host_addr,
2938 txq->drv[i].buf_length); 2938 txq->drv[i].buf_length);
2939 } 2939 }
2940 } 2940 }
2941 #endif 2941 #endif
2942 2942
2943 switch (packet->type) { 2943 switch (packet->type) {
2944 case DATA: 2944 case DATA:
2945 if (txq->drv[txq->oldest].status.info.fields.txType != 0) 2945 if (txq->drv[txq->oldest].status.info.fields.txType != 0)
2946 printk(KERN_WARNING DRV_NAME ": %s: Queue mismatch. " 2946 printk(KERN_WARNING DRV_NAME ": %s: Queue mismatch. "
2947 "Expecting DATA TBD but pulled " 2947 "Expecting DATA TBD but pulled "
2948 "something else: ids %d=%d.\n", 2948 "something else: ids %d=%d.\n",
2949 priv->net_dev->name, txq->oldest, packet->index); 2949 priv->net_dev->name, txq->oldest, packet->index);
2950 2950
2951 /* DATA packet; we have to unmap and free the SKB */ 2951 /* DATA packet; we have to unmap and free the SKB */
2952 for (i = 0; i < frag_num; i++) { 2952 for (i = 0; i < frag_num; i++) {
2953 tbd = &txq->drv[(packet->index + 1 + i) % txq->entries]; 2953 tbd = &txq->drv[(packet->index + 1 + i) % txq->entries];
2954 2954
2955 IPW_DEBUG_TX("TX%d P=%08x L=%d\n", 2955 IPW_DEBUG_TX("TX%d P=%08x L=%d\n",
2956 (packet->index + 1 + i) % txq->entries, 2956 (packet->index + 1 + i) % txq->entries,
2957 tbd->host_addr, tbd->buf_length); 2957 tbd->host_addr, tbd->buf_length);
2958 2958
2959 pci_unmap_single(priv->pci_dev, 2959 pci_unmap_single(priv->pci_dev,
2960 tbd->host_addr, 2960 tbd->host_addr,
2961 tbd->buf_length, PCI_DMA_TODEVICE); 2961 tbd->buf_length, PCI_DMA_TODEVICE);
2962 } 2962 }
2963 2963
2964 libipw_txb_free(packet->info.d_struct.txb); 2964 libipw_txb_free(packet->info.d_struct.txb);
2965 packet->info.d_struct.txb = NULL; 2965 packet->info.d_struct.txb = NULL;
2966 2966
2967 list_add_tail(element, &priv->tx_free_list); 2967 list_add_tail(element, &priv->tx_free_list);
2968 INC_STAT(&priv->tx_free_stat); 2968 INC_STAT(&priv->tx_free_stat);
2969 2969
2970 /* We have a free slot in the Tx queue, so wake up the 2970 /* We have a free slot in the Tx queue, so wake up the
2971 * transmit layer if it is stopped. */ 2971 * transmit layer if it is stopped. */
2972 if (priv->status & STATUS_ASSOCIATED) 2972 if (priv->status & STATUS_ASSOCIATED)
2973 netif_wake_queue(priv->net_dev); 2973 netif_wake_queue(priv->net_dev);
2974 2974
2975 /* A packet was processed by the hardware, so update the 2975 /* A packet was processed by the hardware, so update the
2976 * watchdog */ 2976 * watchdog */
2977 priv->net_dev->trans_start = jiffies; 2977 priv->net_dev->trans_start = jiffies;
2978 2978
2979 break; 2979 break;
2980 2980
2981 case COMMAND: 2981 case COMMAND:
2982 if (txq->drv[txq->oldest].status.info.fields.txType != 1) 2982 if (txq->drv[txq->oldest].status.info.fields.txType != 1)
2983 printk(KERN_WARNING DRV_NAME ": %s: Queue mismatch. " 2983 printk(KERN_WARNING DRV_NAME ": %s: Queue mismatch. "
2984 "Expecting COMMAND TBD but pulled " 2984 "Expecting COMMAND TBD but pulled "
2985 "something else: ids %d=%d.\n", 2985 "something else: ids %d=%d.\n",
2986 priv->net_dev->name, txq->oldest, packet->index); 2986 priv->net_dev->name, txq->oldest, packet->index);
2987 2987
2988 #ifdef CONFIG_IPW2100_DEBUG 2988 #ifdef CONFIG_IPW2100_DEBUG
2989 if (packet->info.c_struct.cmd->host_command_reg < 2989 if (packet->info.c_struct.cmd->host_command_reg <
2990 ARRAY_SIZE(command_types)) 2990 ARRAY_SIZE(command_types))
2991 IPW_DEBUG_TX("Command '%s (%d)' processed: %d.\n", 2991 IPW_DEBUG_TX("Command '%s (%d)' processed: %d.\n",
2992 command_types[packet->info.c_struct.cmd-> 2992 command_types[packet->info.c_struct.cmd->
2993 host_command_reg], 2993 host_command_reg],
2994 packet->info.c_struct.cmd-> 2994 packet->info.c_struct.cmd->
2995 host_command_reg, 2995 host_command_reg,
2996 packet->info.c_struct.cmd->cmd_status_reg); 2996 packet->info.c_struct.cmd->cmd_status_reg);
2997 #endif 2997 #endif
2998 2998
2999 list_add_tail(element, &priv->msg_free_list); 2999 list_add_tail(element, &priv->msg_free_list);
3000 INC_STAT(&priv->msg_free_stat); 3000 INC_STAT(&priv->msg_free_stat);
3001 break; 3001 break;
3002 } 3002 }
3003 3003
3004 /* advance oldest used TBD pointer to start of next entry */ 3004 /* advance oldest used TBD pointer to start of next entry */
3005 txq->oldest = (e + 1) % txq->entries; 3005 txq->oldest = (e + 1) % txq->entries;
3006 /* increase available TBDs number */ 3006 /* increase available TBDs number */
3007 txq->available += descriptors_used; 3007 txq->available += descriptors_used;
3008 SET_STAT(&priv->txq_stat, txq->available); 3008 SET_STAT(&priv->txq_stat, txq->available);
3009 3009
3010 IPW_DEBUG_TX("packet latency (send to process) %ld jiffies\n", 3010 IPW_DEBUG_TX("packet latency (send to process) %ld jiffies\n",
3011 jiffies - packet->jiffy_start); 3011 jiffies - packet->jiffy_start);
3012 3012
3013 return (!list_empty(&priv->fw_pend_list)); 3013 return (!list_empty(&priv->fw_pend_list));
3014 } 3014 }
3015 3015
3016 static inline void __ipw2100_tx_complete(struct ipw2100_priv *priv) 3016 static inline void __ipw2100_tx_complete(struct ipw2100_priv *priv)
3017 { 3017 {
3018 int i = 0; 3018 int i = 0;
3019 3019
3020 while (__ipw2100_tx_process(priv) && i < 200) 3020 while (__ipw2100_tx_process(priv) && i < 200)
3021 i++; 3021 i++;
3022 3022
3023 if (i == 200) { 3023 if (i == 200) {
3024 printk(KERN_WARNING DRV_NAME ": " 3024 printk(KERN_WARNING DRV_NAME ": "
3025 "%s: Driver is running slow (%d iters).\n", 3025 "%s: Driver is running slow (%d iters).\n",
3026 priv->net_dev->name, i); 3026 priv->net_dev->name, i);
3027 } 3027 }
3028 } 3028 }
3029 3029
3030 static void ipw2100_tx_send_commands(struct ipw2100_priv *priv) 3030 static void ipw2100_tx_send_commands(struct ipw2100_priv *priv)
3031 { 3031 {
3032 struct list_head *element; 3032 struct list_head *element;
3033 struct ipw2100_tx_packet *packet; 3033 struct ipw2100_tx_packet *packet;
3034 struct ipw2100_bd_queue *txq = &priv->tx_queue; 3034 struct ipw2100_bd_queue *txq = &priv->tx_queue;
3035 struct ipw2100_bd *tbd; 3035 struct ipw2100_bd *tbd;
3036 int next = txq->next; 3036 int next = txq->next;
3037 3037
3038 while (!list_empty(&priv->msg_pend_list)) { 3038 while (!list_empty(&priv->msg_pend_list)) {
3039 /* if there isn't enough space in TBD queue, then 3039 /* if there isn't enough space in TBD queue, then
3040 * don't stuff a new one in. 3040 * don't stuff a new one in.
3041 * NOTE: 3 are needed as a command will take one, 3041 * NOTE: 3 are needed as a command will take one,
3042 * and there is a minimum of 2 that must be 3042 * and there is a minimum of 2 that must be
3043 * maintained between the r and w indexes 3043 * maintained between the r and w indexes
3044 */ 3044 */
3045 if (txq->available <= 3) { 3045 if (txq->available <= 3) {
3046 IPW_DEBUG_TX("no room in tx_queue\n"); 3046 IPW_DEBUG_TX("no room in tx_queue\n");
3047 break; 3047 break;
3048 } 3048 }
3049 3049
3050 element = priv->msg_pend_list.next; 3050 element = priv->msg_pend_list.next;
3051 list_del(element); 3051 list_del(element);
3052 DEC_STAT(&priv->msg_pend_stat); 3052 DEC_STAT(&priv->msg_pend_stat);
3053 3053
3054 packet = list_entry(element, struct ipw2100_tx_packet, list); 3054 packet = list_entry(element, struct ipw2100_tx_packet, list);
3055 3055
3056 IPW_DEBUG_TX("using TBD at virt=%p, phys=%04X\n", 3056 IPW_DEBUG_TX("using TBD at virt=%p, phys=%04X\n",
3057 &txq->drv[txq->next], 3057 &txq->drv[txq->next],
3058 (u32) (txq->nic + txq->next * 3058 (u32) (txq->nic + txq->next *
3059 sizeof(struct ipw2100_bd))); 3059 sizeof(struct ipw2100_bd)));
3060 3060
3061 packet->index = txq->next; 3061 packet->index = txq->next;
3062 3062
3063 tbd = &txq->drv[txq->next]; 3063 tbd = &txq->drv[txq->next];
3064 3064
3065 /* initialize TBD */ 3065 /* initialize TBD */
3066 tbd->host_addr = packet->info.c_struct.cmd_phys; 3066 tbd->host_addr = packet->info.c_struct.cmd_phys;
3067 tbd->buf_length = sizeof(struct ipw2100_cmd_header); 3067 tbd->buf_length = sizeof(struct ipw2100_cmd_header);
3068 /* not marking number of fragments causes problems 3068 /* not marking number of fragments causes problems
3069 * with f/w debug version */ 3069 * with f/w debug version */
3070 tbd->num_fragments = 1; 3070 tbd->num_fragments = 1;
3071 tbd->status.info.field = 3071 tbd->status.info.field =
3072 IPW_BD_STATUS_TX_FRAME_COMMAND | 3072 IPW_BD_STATUS_TX_FRAME_COMMAND |
3073 IPW_BD_STATUS_TX_INTERRUPT_ENABLE; 3073 IPW_BD_STATUS_TX_INTERRUPT_ENABLE;
3074 3074
3075 /* update TBD queue counters */ 3075 /* update TBD queue counters */
3076 txq->next++; 3076 txq->next++;
3077 txq->next %= txq->entries; 3077 txq->next %= txq->entries;
3078 txq->available--; 3078 txq->available--;
3079 DEC_STAT(&priv->txq_stat); 3079 DEC_STAT(&priv->txq_stat);
3080 3080
3081 list_add_tail(element, &priv->fw_pend_list); 3081 list_add_tail(element, &priv->fw_pend_list);
3082 INC_STAT(&priv->fw_pend_stat); 3082 INC_STAT(&priv->fw_pend_stat);
3083 } 3083 }
3084 3084
3085 if (txq->next != next) { 3085 if (txq->next != next) {
3086 /* kick off the DMA by notifying firmware the 3086 /* kick off the DMA by notifying firmware the
3087 * write index has moved; make sure TBD stores are sync'd */ 3087 * write index has moved; make sure TBD stores are sync'd */
3088 wmb(); 3088 wmb();
3089 write_register(priv->net_dev, 3089 write_register(priv->net_dev,
3090 IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX, 3090 IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX,
3091 txq->next); 3091 txq->next);
3092 } 3092 }
3093 } 3093 }
3094 3094
3095 /* 3095 /*
3096 * ipw2100_tx_send_data 3096 * ipw2100_tx_send_data
3097 * 3097 *
3098 */ 3098 */
3099 static void ipw2100_tx_send_data(struct ipw2100_priv *priv) 3099 static void ipw2100_tx_send_data(struct ipw2100_priv *priv)
3100 { 3100 {
3101 struct list_head *element; 3101 struct list_head *element;
3102 struct ipw2100_tx_packet *packet; 3102 struct ipw2100_tx_packet *packet;
3103 struct ipw2100_bd_queue *txq = &priv->tx_queue; 3103 struct ipw2100_bd_queue *txq = &priv->tx_queue;
3104 struct ipw2100_bd *tbd; 3104 struct ipw2100_bd *tbd;
3105 int next = txq->next; 3105 int next = txq->next;
3106 int i = 0; 3106 int i = 0;
3107 struct ipw2100_data_header *ipw_hdr; 3107 struct ipw2100_data_header *ipw_hdr;
3108 struct libipw_hdr_3addr *hdr; 3108 struct libipw_hdr_3addr *hdr;
3109 3109
3110 while (!list_empty(&priv->tx_pend_list)) { 3110 while (!list_empty(&priv->tx_pend_list)) {
3111 /* if there isn't enough space in TBD queue, then 3111 /* if there isn't enough space in TBD queue, then
3112 * don't stuff a new one in. 3112 * don't stuff a new one in.
3113 * NOTE: 4 are needed as a data will take two, 3113 * NOTE: 4 are needed as a data will take two,
3114 * and there is a minimum of 2 that must be 3114 * and there is a minimum of 2 that must be
3115 * maintained between the r and w indexes 3115 * maintained between the r and w indexes
3116 */ 3116 */
3117 element = priv->tx_pend_list.next; 3117 element = priv->tx_pend_list.next;
3118 packet = list_entry(element, struct ipw2100_tx_packet, list); 3118 packet = list_entry(element, struct ipw2100_tx_packet, list);
3119 3119
3120 if (unlikely(1 + packet->info.d_struct.txb->nr_frags > 3120 if (unlikely(1 + packet->info.d_struct.txb->nr_frags >
3121 IPW_MAX_BDS)) { 3121 IPW_MAX_BDS)) {
3122 /* TODO: Support merging buffers if more than 3122 /* TODO: Support merging buffers if more than
3123 * IPW_MAX_BDS are used */ 3123 * IPW_MAX_BDS are used */
3124 IPW_DEBUG_INFO("%s: Maximum BD threshold exceeded. " 3124 IPW_DEBUG_INFO("%s: Maximum BD threshold exceeded. "
3125 "Increase fragmentation level.\n", 3125 "Increase fragmentation level.\n",
3126 priv->net_dev->name); 3126 priv->net_dev->name);
3127 } 3127 }
3128 3128
3129 if (txq->available <= 3 + packet->info.d_struct.txb->nr_frags) { 3129 if (txq->available <= 3 + packet->info.d_struct.txb->nr_frags) {
3130 IPW_DEBUG_TX("no room in tx_queue\n"); 3130 IPW_DEBUG_TX("no room in tx_queue\n");
3131 break; 3131 break;
3132 } 3132 }
3133 3133
3134 list_del(element); 3134 list_del(element);
3135 DEC_STAT(&priv->tx_pend_stat); 3135 DEC_STAT(&priv->tx_pend_stat);
3136 3136
3137 tbd = &txq->drv[txq->next]; 3137 tbd = &txq->drv[txq->next];
3138 3138
3139 packet->index = txq->next; 3139 packet->index = txq->next;
3140 3140
3141 ipw_hdr = packet->info.d_struct.data; 3141 ipw_hdr = packet->info.d_struct.data;
3142 hdr = (struct libipw_hdr_3addr *)packet->info.d_struct.txb-> 3142 hdr = (struct libipw_hdr_3addr *)packet->info.d_struct.txb->
3143 fragments[0]->data; 3143 fragments[0]->data;
3144 3144
3145 if (priv->ieee->iw_mode == IW_MODE_INFRA) { 3145 if (priv->ieee->iw_mode == IW_MODE_INFRA) {
3146 /* To DS: Addr1 = BSSID, Addr2 = SA, 3146 /* To DS: Addr1 = BSSID, Addr2 = SA,
3147 Addr3 = DA */ 3147 Addr3 = DA */
3148 memcpy(ipw_hdr->src_addr, hdr->addr2, ETH_ALEN); 3148 memcpy(ipw_hdr->src_addr, hdr->addr2, ETH_ALEN);
3149 memcpy(ipw_hdr->dst_addr, hdr->addr3, ETH_ALEN); 3149 memcpy(ipw_hdr->dst_addr, hdr->addr3, ETH_ALEN);
3150 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) { 3150 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
3151 /* not From/To DS: Addr1 = DA, Addr2 = SA, 3151 /* not From/To DS: Addr1 = DA, Addr2 = SA,
3152 Addr3 = BSSID */ 3152 Addr3 = BSSID */
3153 memcpy(ipw_hdr->src_addr, hdr->addr2, ETH_ALEN); 3153 memcpy(ipw_hdr->src_addr, hdr->addr2, ETH_ALEN);
3154 memcpy(ipw_hdr->dst_addr, hdr->addr1, ETH_ALEN); 3154 memcpy(ipw_hdr->dst_addr, hdr->addr1, ETH_ALEN);
3155 } 3155 }
3156 3156
3157 ipw_hdr->host_command_reg = SEND; 3157 ipw_hdr->host_command_reg = SEND;
3158 ipw_hdr->host_command_reg1 = 0; 3158 ipw_hdr->host_command_reg1 = 0;
3159 3159
3160 /* For now we only support host based encryption */ 3160 /* For now we only support host based encryption */
3161 ipw_hdr->needs_encryption = 0; 3161 ipw_hdr->needs_encryption = 0;
3162 ipw_hdr->encrypted = packet->info.d_struct.txb->encrypted; 3162 ipw_hdr->encrypted = packet->info.d_struct.txb->encrypted;
3163 if (packet->info.d_struct.txb->nr_frags > 1) 3163 if (packet->info.d_struct.txb->nr_frags > 1)
3164 ipw_hdr->fragment_size = 3164 ipw_hdr->fragment_size =
3165 packet->info.d_struct.txb->frag_size - 3165 packet->info.d_struct.txb->frag_size -
3166 LIBIPW_3ADDR_LEN; 3166 LIBIPW_3ADDR_LEN;
3167 else 3167 else
3168 ipw_hdr->fragment_size = 0; 3168 ipw_hdr->fragment_size = 0;
3169 3169
3170 tbd->host_addr = packet->info.d_struct.data_phys; 3170 tbd->host_addr = packet->info.d_struct.data_phys;
3171 tbd->buf_length = sizeof(struct ipw2100_data_header); 3171 tbd->buf_length = sizeof(struct ipw2100_data_header);
3172 tbd->num_fragments = 1 + packet->info.d_struct.txb->nr_frags; 3172 tbd->num_fragments = 1 + packet->info.d_struct.txb->nr_frags;
3173 tbd->status.info.field = 3173 tbd->status.info.field =
3174 IPW_BD_STATUS_TX_FRAME_802_3 | 3174 IPW_BD_STATUS_TX_FRAME_802_3 |
3175 IPW_BD_STATUS_TX_FRAME_NOT_LAST_FRAGMENT; 3175 IPW_BD_STATUS_TX_FRAME_NOT_LAST_FRAGMENT;
3176 txq->next++; 3176 txq->next++;
3177 txq->next %= txq->entries; 3177 txq->next %= txq->entries;
3178 3178
3179 IPW_DEBUG_TX("data header tbd TX%d P=%08x L=%d\n", 3179 IPW_DEBUG_TX("data header tbd TX%d P=%08x L=%d\n",
3180 packet->index, tbd->host_addr, tbd->buf_length); 3180 packet->index, tbd->host_addr, tbd->buf_length);
3181 #ifdef CONFIG_IPW2100_DEBUG 3181 #ifdef CONFIG_IPW2100_DEBUG
3182 if (packet->info.d_struct.txb->nr_frags > 1) 3182 if (packet->info.d_struct.txb->nr_frags > 1)
3183 IPW_DEBUG_FRAG("fragment Tx: %d frames\n", 3183 IPW_DEBUG_FRAG("fragment Tx: %d frames\n",
3184 packet->info.d_struct.txb->nr_frags); 3184 packet->info.d_struct.txb->nr_frags);
3185 #endif 3185 #endif
3186 3186
3187 for (i = 0; i < packet->info.d_struct.txb->nr_frags; i++) { 3187 for (i = 0; i < packet->info.d_struct.txb->nr_frags; i++) {
3188 tbd = &txq->drv[txq->next]; 3188 tbd = &txq->drv[txq->next];
3189 if (i == packet->info.d_struct.txb->nr_frags - 1) 3189 if (i == packet->info.d_struct.txb->nr_frags - 1)
3190 tbd->status.info.field = 3190 tbd->status.info.field =
3191 IPW_BD_STATUS_TX_FRAME_802_3 | 3191 IPW_BD_STATUS_TX_FRAME_802_3 |
3192 IPW_BD_STATUS_TX_INTERRUPT_ENABLE; 3192 IPW_BD_STATUS_TX_INTERRUPT_ENABLE;
3193 else 3193 else
3194 tbd->status.info.field = 3194 tbd->status.info.field =
3195 IPW_BD_STATUS_TX_FRAME_802_3 | 3195 IPW_BD_STATUS_TX_FRAME_802_3 |
3196 IPW_BD_STATUS_TX_FRAME_NOT_LAST_FRAGMENT; 3196 IPW_BD_STATUS_TX_FRAME_NOT_LAST_FRAGMENT;
3197 3197
3198 tbd->buf_length = packet->info.d_struct.txb-> 3198 tbd->buf_length = packet->info.d_struct.txb->
3199 fragments[i]->len - LIBIPW_3ADDR_LEN; 3199 fragments[i]->len - LIBIPW_3ADDR_LEN;
3200 3200
3201 tbd->host_addr = pci_map_single(priv->pci_dev, 3201 tbd->host_addr = pci_map_single(priv->pci_dev,
3202 packet->info.d_struct. 3202 packet->info.d_struct.
3203 txb->fragments[i]-> 3203 txb->fragments[i]->
3204 data + 3204 data +
3205 LIBIPW_3ADDR_LEN, 3205 LIBIPW_3ADDR_LEN,
3206 tbd->buf_length, 3206 tbd->buf_length,
3207 PCI_DMA_TODEVICE); 3207 PCI_DMA_TODEVICE);
3208 3208
3209 IPW_DEBUG_TX("data frag tbd TX%d P=%08x L=%d\n", 3209 IPW_DEBUG_TX("data frag tbd TX%d P=%08x L=%d\n",
3210 txq->next, tbd->host_addr, 3210 txq->next, tbd->host_addr,
3211 tbd->buf_length); 3211 tbd->buf_length);
3212 3212
3213 pci_dma_sync_single_for_device(priv->pci_dev, 3213 pci_dma_sync_single_for_device(priv->pci_dev,
3214 tbd->host_addr, 3214 tbd->host_addr,
3215 tbd->buf_length, 3215 tbd->buf_length,
3216 PCI_DMA_TODEVICE); 3216 PCI_DMA_TODEVICE);
3217 3217
3218 txq->next++; 3218 txq->next++;
3219 txq->next %= txq->entries; 3219 txq->next %= txq->entries;
3220 } 3220 }
3221 3221
3222 txq->available -= 1 + packet->info.d_struct.txb->nr_frags; 3222 txq->available -= 1 + packet->info.d_struct.txb->nr_frags;
3223 SET_STAT(&priv->txq_stat, txq->available); 3223 SET_STAT(&priv->txq_stat, txq->available);
3224 3224
3225 list_add_tail(element, &priv->fw_pend_list); 3225 list_add_tail(element, &priv->fw_pend_list);
3226 INC_STAT(&priv->fw_pend_stat); 3226 INC_STAT(&priv->fw_pend_stat);
3227 } 3227 }
3228 3228
3229 if (txq->next != next) { 3229 if (txq->next != next) {
3230 /* kick off the DMA by notifying firmware the 3230 /* kick off the DMA by notifying firmware the
3231 * write index has moved; make sure TBD stores are sync'd */ 3231 * write index has moved; make sure TBD stores are sync'd */
3232 write_register(priv->net_dev, 3232 write_register(priv->net_dev,
3233 IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX, 3233 IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX,
3234 txq->next); 3234 txq->next);
3235 } 3235 }
3236 } 3236 }
3237 3237
3238 static void ipw2100_irq_tasklet(struct ipw2100_priv *priv) 3238 static void ipw2100_irq_tasklet(struct ipw2100_priv *priv)
3239 { 3239 {
3240 struct net_device *dev = priv->net_dev; 3240 struct net_device *dev = priv->net_dev;
3241 unsigned long flags; 3241 unsigned long flags;
3242 u32 inta, tmp; 3242 u32 inta, tmp;
3243 3243
3244 spin_lock_irqsave(&priv->low_lock, flags); 3244 spin_lock_irqsave(&priv->low_lock, flags);
3245 ipw2100_disable_interrupts(priv); 3245 ipw2100_disable_interrupts(priv);
3246 3246
3247 read_register(dev, IPW_REG_INTA, &inta); 3247 read_register(dev, IPW_REG_INTA, &inta);
3248 3248
3249 IPW_DEBUG_ISR("enter - INTA: 0x%08lX\n", 3249 IPW_DEBUG_ISR("enter - INTA: 0x%08lX\n",
3250 (unsigned long)inta & IPW_INTERRUPT_MASK); 3250 (unsigned long)inta & IPW_INTERRUPT_MASK);
3251 3251
3252 priv->in_isr++; 3252 priv->in_isr++;
3253 priv->interrupts++; 3253 priv->interrupts++;
3254 3254
3255 /* We do not loop and keep polling for more interrupts as this 3255 /* We do not loop and keep polling for more interrupts as this
3256 * is frowned upon and doesn't play nicely with other potentially 3256 * is frowned upon and doesn't play nicely with other potentially
3257 * chained IRQs */ 3257 * chained IRQs */
3258 IPW_DEBUG_ISR("INTA: 0x%08lX\n", 3258 IPW_DEBUG_ISR("INTA: 0x%08lX\n",
3259 (unsigned long)inta & IPW_INTERRUPT_MASK); 3259 (unsigned long)inta & IPW_INTERRUPT_MASK);
3260 3260
3261 if (inta & IPW2100_INTA_FATAL_ERROR) { 3261 if (inta & IPW2100_INTA_FATAL_ERROR) {
3262 printk(KERN_WARNING DRV_NAME 3262 printk(KERN_WARNING DRV_NAME
3263 ": Fatal interrupt. Scheduling firmware restart.\n"); 3263 ": Fatal interrupt. Scheduling firmware restart.\n");
3264 priv->inta_other++; 3264 priv->inta_other++;
3265 write_register(dev, IPW_REG_INTA, IPW2100_INTA_FATAL_ERROR); 3265 write_register(dev, IPW_REG_INTA, IPW2100_INTA_FATAL_ERROR);
3266 3266
3267 read_nic_dword(dev, IPW_NIC_FATAL_ERROR, &priv->fatal_error); 3267 read_nic_dword(dev, IPW_NIC_FATAL_ERROR, &priv->fatal_error);
3268 IPW_DEBUG_INFO("%s: Fatal error value: 0x%08X\n", 3268 IPW_DEBUG_INFO("%s: Fatal error value: 0x%08X\n",
3269 priv->net_dev->name, priv->fatal_error); 3269 priv->net_dev->name, priv->fatal_error);
3270 3270
3271 read_nic_dword(dev, IPW_ERROR_ADDR(priv->fatal_error), &tmp); 3271 read_nic_dword(dev, IPW_ERROR_ADDR(priv->fatal_error), &tmp);
3272 IPW_DEBUG_INFO("%s: Fatal error address value: 0x%08X\n", 3272 IPW_DEBUG_INFO("%s: Fatal error address value: 0x%08X\n",
3273 priv->net_dev->name, tmp); 3273 priv->net_dev->name, tmp);
3274 3274
3275 /* Wake up any sleeping jobs */ 3275 /* Wake up any sleeping jobs */
3276 schedule_reset(priv); 3276 schedule_reset(priv);
3277 } 3277 }
3278 3278
3279 if (inta & IPW2100_INTA_PARITY_ERROR) { 3279 if (inta & IPW2100_INTA_PARITY_ERROR) {
3280 printk(KERN_ERR DRV_NAME 3280 printk(KERN_ERR DRV_NAME
3281 ": ***** PARITY ERROR INTERRUPT !!!!\n"); 3281 ": ***** PARITY ERROR INTERRUPT !!!!\n");
3282 priv->inta_other++; 3282 priv->inta_other++;
3283 write_register(dev, IPW_REG_INTA, IPW2100_INTA_PARITY_ERROR); 3283 write_register(dev, IPW_REG_INTA, IPW2100_INTA_PARITY_ERROR);
3284 } 3284 }
3285 3285
3286 if (inta & IPW2100_INTA_RX_TRANSFER) { 3286 if (inta & IPW2100_INTA_RX_TRANSFER) {
3287 IPW_DEBUG_ISR("RX interrupt\n"); 3287 IPW_DEBUG_ISR("RX interrupt\n");
3288 3288
3289 priv->rx_interrupts++; 3289 priv->rx_interrupts++;
3290 3290
3291 write_register(dev, IPW_REG_INTA, IPW2100_INTA_RX_TRANSFER); 3291 write_register(dev, IPW_REG_INTA, IPW2100_INTA_RX_TRANSFER);
3292 3292
3293 __ipw2100_rx_process(priv); 3293 __ipw2100_rx_process(priv);
3294 __ipw2100_tx_complete(priv); 3294 __ipw2100_tx_complete(priv);
3295 } 3295 }
3296 3296
3297 if (inta & IPW2100_INTA_TX_TRANSFER) { 3297 if (inta & IPW2100_INTA_TX_TRANSFER) {
3298 IPW_DEBUG_ISR("TX interrupt\n"); 3298 IPW_DEBUG_ISR("TX interrupt\n");
3299 3299
3300 priv->tx_interrupts++; 3300 priv->tx_interrupts++;
3301 3301
3302 write_register(dev, IPW_REG_INTA, IPW2100_INTA_TX_TRANSFER); 3302 write_register(dev, IPW_REG_INTA, IPW2100_INTA_TX_TRANSFER);
3303 3303
3304 __ipw2100_tx_complete(priv); 3304 __ipw2100_tx_complete(priv);
3305 ipw2100_tx_send_commands(priv); 3305 ipw2100_tx_send_commands(priv);
3306 ipw2100_tx_send_data(priv); 3306 ipw2100_tx_send_data(priv);
3307 } 3307 }
3308 3308
3309 if (inta & IPW2100_INTA_TX_COMPLETE) { 3309 if (inta & IPW2100_INTA_TX_COMPLETE) {
3310 IPW_DEBUG_ISR("TX complete\n"); 3310 IPW_DEBUG_ISR("TX complete\n");
3311 priv->inta_other++; 3311 priv->inta_other++;
3312 write_register(dev, IPW_REG_INTA, IPW2100_INTA_TX_COMPLETE); 3312 write_register(dev, IPW_REG_INTA, IPW2100_INTA_TX_COMPLETE);
3313 3313
3314 __ipw2100_tx_complete(priv); 3314 __ipw2100_tx_complete(priv);
3315 } 3315 }
3316 3316
3317 if (inta & IPW2100_INTA_EVENT_INTERRUPT) { 3317 if (inta & IPW2100_INTA_EVENT_INTERRUPT) {
3318 /* ipw2100_handle_event(dev); */ 3318 /* ipw2100_handle_event(dev); */
3319 priv->inta_other++; 3319 priv->inta_other++;
3320 write_register(dev, IPW_REG_INTA, IPW2100_INTA_EVENT_INTERRUPT); 3320 write_register(dev, IPW_REG_INTA, IPW2100_INTA_EVENT_INTERRUPT);
3321 } 3321 }
3322 3322
3323 if (inta & IPW2100_INTA_FW_INIT_DONE) { 3323 if (inta & IPW2100_INTA_FW_INIT_DONE) {
3324 IPW_DEBUG_ISR("FW init done interrupt\n"); 3324 IPW_DEBUG_ISR("FW init done interrupt\n");
3325 priv->inta_other++; 3325 priv->inta_other++;
3326 3326
3327 read_register(dev, IPW_REG_INTA, &tmp); 3327 read_register(dev, IPW_REG_INTA, &tmp);
3328 if (tmp & (IPW2100_INTA_FATAL_ERROR | 3328 if (tmp & (IPW2100_INTA_FATAL_ERROR |
3329 IPW2100_INTA_PARITY_ERROR)) { 3329 IPW2100_INTA_PARITY_ERROR)) {
3330 write_register(dev, IPW_REG_INTA, 3330 write_register(dev, IPW_REG_INTA,
3331 IPW2100_INTA_FATAL_ERROR | 3331 IPW2100_INTA_FATAL_ERROR |
3332 IPW2100_INTA_PARITY_ERROR); 3332 IPW2100_INTA_PARITY_ERROR);
3333 } 3333 }
3334 3334
3335 write_register(dev, IPW_REG_INTA, IPW2100_INTA_FW_INIT_DONE); 3335 write_register(dev, IPW_REG_INTA, IPW2100_INTA_FW_INIT_DONE);
3336 } 3336 }
3337 3337
3338 if (inta & IPW2100_INTA_STATUS_CHANGE) { 3338 if (inta & IPW2100_INTA_STATUS_CHANGE) {
3339 IPW_DEBUG_ISR("Status change interrupt\n"); 3339 IPW_DEBUG_ISR("Status change interrupt\n");
3340 priv->inta_other++; 3340 priv->inta_other++;
3341 write_register(dev, IPW_REG_INTA, IPW2100_INTA_STATUS_CHANGE); 3341 write_register(dev, IPW_REG_INTA, IPW2100_INTA_STATUS_CHANGE);
3342 } 3342 }
3343 3343
3344 if (inta & IPW2100_INTA_SLAVE_MODE_HOST_COMMAND_DONE) { 3344 if (inta & IPW2100_INTA_SLAVE_MODE_HOST_COMMAND_DONE) {
3345 IPW_DEBUG_ISR("slave host mode interrupt\n"); 3345 IPW_DEBUG_ISR("slave host mode interrupt\n");
3346 priv->inta_other++; 3346 priv->inta_other++;
3347 write_register(dev, IPW_REG_INTA, 3347 write_register(dev, IPW_REG_INTA,
3348 IPW2100_INTA_SLAVE_MODE_HOST_COMMAND_DONE); 3348 IPW2100_INTA_SLAVE_MODE_HOST_COMMAND_DONE);
3349 } 3349 }
3350 3350
3351 priv->in_isr--; 3351 priv->in_isr--;
3352 ipw2100_enable_interrupts(priv); 3352 ipw2100_enable_interrupts(priv);
3353 3353
3354 spin_unlock_irqrestore(&priv->low_lock, flags); 3354 spin_unlock_irqrestore(&priv->low_lock, flags);
3355 3355
3356 IPW_DEBUG_ISR("exit\n"); 3356 IPW_DEBUG_ISR("exit\n");
3357 } 3357 }
3358 3358
3359 static irqreturn_t ipw2100_interrupt(int irq, void *data) 3359 static irqreturn_t ipw2100_interrupt(int irq, void *data)
3360 { 3360 {
3361 struct ipw2100_priv *priv = data; 3361 struct ipw2100_priv *priv = data;
3362 u32 inta, inta_mask; 3362 u32 inta, inta_mask;
3363 3363
3364 if (!data) 3364 if (!data)
3365 return IRQ_NONE; 3365 return IRQ_NONE;
3366 3366
3367 spin_lock(&priv->low_lock); 3367 spin_lock(&priv->low_lock);
3368 3368
3369 /* We check to see if we should be ignoring interrupts before 3369 /* We check to see if we should be ignoring interrupts before
3370 * we touch the hardware. During ucode load if we try and handle 3370 * we touch the hardware. During ucode load if we try and handle
3371 * an interrupt we can cause keyboard problems as well as cause 3371 * an interrupt we can cause keyboard problems as well as cause
3372 * the ucode to fail to initialize */ 3372 * the ucode to fail to initialize */
3373 if (!(priv->status & STATUS_INT_ENABLED)) { 3373 if (!(priv->status & STATUS_INT_ENABLED)) {
3374 /* Shared IRQ */ 3374 /* Shared IRQ */
3375 goto none; 3375 goto none;
3376 } 3376 }
3377 3377
3378 read_register(priv->net_dev, IPW_REG_INTA_MASK, &inta_mask); 3378 read_register(priv->net_dev, IPW_REG_INTA_MASK, &inta_mask);
3379 read_register(priv->net_dev, IPW_REG_INTA, &inta); 3379 read_register(priv->net_dev, IPW_REG_INTA, &inta);
3380 3380
3381 if (inta == 0xFFFFFFFF) { 3381 if (inta == 0xFFFFFFFF) {
3382 /* Hardware disappeared */ 3382 /* Hardware disappeared */
3383 printk(KERN_WARNING DRV_NAME ": IRQ INTA == 0xFFFFFFFF\n"); 3383 printk(KERN_WARNING DRV_NAME ": IRQ INTA == 0xFFFFFFFF\n");
3384 goto none; 3384 goto none;
3385 } 3385 }
3386 3386
3387 inta &= IPW_INTERRUPT_MASK; 3387 inta &= IPW_INTERRUPT_MASK;
3388 3388
3389 if (!(inta & inta_mask)) { 3389 if (!(inta & inta_mask)) {
3390 /* Shared interrupt */ 3390 /* Shared interrupt */
3391 goto none; 3391 goto none;
3392 } 3392 }
3393 3393
3394 /* We disable the hardware interrupt here just to prevent unneeded 3394 /* We disable the hardware interrupt here just to prevent unneeded
3395 * calls to be made. We disable this again within the actual 3395 * calls to be made. We disable this again within the actual
3396 * work tasklet, so if another part of the code re-enables the 3396 * work tasklet, so if another part of the code re-enables the
3397 * interrupt, that is fine */ 3397 * interrupt, that is fine */
3398 ipw2100_disable_interrupts(priv); 3398 ipw2100_disable_interrupts(priv);
3399 3399
3400 tasklet_schedule(&priv->irq_tasklet); 3400 tasklet_schedule(&priv->irq_tasklet);
3401 spin_unlock(&priv->low_lock); 3401 spin_unlock(&priv->low_lock);
3402 3402
3403 return IRQ_HANDLED; 3403 return IRQ_HANDLED;
3404 none: 3404 none:
3405 spin_unlock(&priv->low_lock); 3405 spin_unlock(&priv->low_lock);
3406 return IRQ_NONE; 3406 return IRQ_NONE;
3407 } 3407 }
3408 3408
3409 static netdev_tx_t ipw2100_tx(struct libipw_txb *txb, 3409 static netdev_tx_t ipw2100_tx(struct libipw_txb *txb,
3410 struct net_device *dev, int pri) 3410 struct net_device *dev, int pri)
3411 { 3411 {
3412 struct ipw2100_priv *priv = libipw_priv(dev); 3412 struct ipw2100_priv *priv = libipw_priv(dev);
3413 struct list_head *element; 3413 struct list_head *element;
3414 struct ipw2100_tx_packet *packet; 3414 struct ipw2100_tx_packet *packet;
3415 unsigned long flags; 3415 unsigned long flags;
3416 3416
3417 spin_lock_irqsave(&priv->low_lock, flags); 3417 spin_lock_irqsave(&priv->low_lock, flags);
3418 3418
3419 if (!(priv->status & STATUS_ASSOCIATED)) { 3419 if (!(priv->status & STATUS_ASSOCIATED)) {
3420 IPW_DEBUG_INFO("Can not transmit when not connected.\n"); 3420 IPW_DEBUG_INFO("Can not transmit when not connected.\n");
3421 priv->net_dev->stats.tx_carrier_errors++; 3421 priv->net_dev->stats.tx_carrier_errors++;
3422 netif_stop_queue(dev); 3422 netif_stop_queue(dev);
3423 goto fail_unlock; 3423 goto fail_unlock;
3424 } 3424 }
3425 3425
3426 if (list_empty(&priv->tx_free_list)) 3426 if (list_empty(&priv->tx_free_list))
3427 goto fail_unlock; 3427 goto fail_unlock;
3428 3428
3429 element = priv->tx_free_list.next; 3429 element = priv->tx_free_list.next;
3430 packet = list_entry(element, struct ipw2100_tx_packet, list); 3430 packet = list_entry(element, struct ipw2100_tx_packet, list);
3431 3431
3432 packet->info.d_struct.txb = txb; 3432 packet->info.d_struct.txb = txb;
3433 3433
3434 IPW_DEBUG_TX("Sending fragment (%d bytes):\n", txb->fragments[0]->len); 3434 IPW_DEBUG_TX("Sending fragment (%d bytes):\n", txb->fragments[0]->len);
3435 printk_buf(IPW_DL_TX, txb->fragments[0]->data, txb->fragments[0]->len); 3435 printk_buf(IPW_DL_TX, txb->fragments[0]->data, txb->fragments[0]->len);
3436 3436
3437 packet->jiffy_start = jiffies; 3437 packet->jiffy_start = jiffies;
3438 3438
3439 list_del(element); 3439 list_del(element);
3440 DEC_STAT(&priv->tx_free_stat); 3440 DEC_STAT(&priv->tx_free_stat);
3441 3441
3442 list_add_tail(element, &priv->tx_pend_list); 3442 list_add_tail(element, &priv->tx_pend_list);
3443 INC_STAT(&priv->tx_pend_stat); 3443 INC_STAT(&priv->tx_pend_stat);
3444 3444
3445 ipw2100_tx_send_data(priv); 3445 ipw2100_tx_send_data(priv);
3446 3446
3447 spin_unlock_irqrestore(&priv->low_lock, flags); 3447 spin_unlock_irqrestore(&priv->low_lock, flags);
3448 return NETDEV_TX_OK; 3448 return NETDEV_TX_OK;
3449 3449
3450 fail_unlock: 3450 fail_unlock:
3451 netif_stop_queue(dev); 3451 netif_stop_queue(dev);
3452 spin_unlock_irqrestore(&priv->low_lock, flags); 3452 spin_unlock_irqrestore(&priv->low_lock, flags);
3453 return NETDEV_TX_BUSY; 3453 return NETDEV_TX_BUSY;
3454 } 3454 }
3455 3455
3456 static int ipw2100_msg_allocate(struct ipw2100_priv *priv) 3456 static int ipw2100_msg_allocate(struct ipw2100_priv *priv)
3457 { 3457 {
3458 int i, j, err = -EINVAL; 3458 int i, j, err = -EINVAL;
3459 void *v; 3459 void *v;
3460 dma_addr_t p; 3460 dma_addr_t p;
3461 3461
3462 priv->msg_buffers = 3462 priv->msg_buffers =
3463 kmalloc(IPW_COMMAND_POOL_SIZE * sizeof(struct ipw2100_tx_packet), 3463 kmalloc(IPW_COMMAND_POOL_SIZE * sizeof(struct ipw2100_tx_packet),
3464 GFP_KERNEL); 3464 GFP_KERNEL);
3465 if (!priv->msg_buffers) { 3465 if (!priv->msg_buffers) {
3466 printk(KERN_ERR DRV_NAME ": %s: PCI alloc failed for msg " 3466 printk(KERN_ERR DRV_NAME ": %s: PCI alloc failed for msg "
3467 "buffers.\n", priv->net_dev->name); 3467 "buffers.\n", priv->net_dev->name);
3468 return -ENOMEM; 3468 return -ENOMEM;
3469 } 3469 }
3470 3470
3471 for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++) { 3471 for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++) {
3472 v = pci_alloc_consistent(priv->pci_dev, 3472 v = pci_alloc_consistent(priv->pci_dev,
3473 sizeof(struct ipw2100_cmd_header), &p); 3473 sizeof(struct ipw2100_cmd_header), &p);
3474 if (!v) { 3474 if (!v) {
3475 printk(KERN_ERR DRV_NAME ": " 3475 printk(KERN_ERR DRV_NAME ": "
3476 "%s: PCI alloc failed for msg " 3476 "%s: PCI alloc failed for msg "
3477 "buffers.\n", priv->net_dev->name); 3477 "buffers.\n", priv->net_dev->name);
3478 err = -ENOMEM; 3478 err = -ENOMEM;
3479 break; 3479 break;
3480 } 3480 }
3481 3481
3482 memset(v, 0, sizeof(struct ipw2100_cmd_header)); 3482 memset(v, 0, sizeof(struct ipw2100_cmd_header));
3483 3483
3484 priv->msg_buffers[i].type = COMMAND; 3484 priv->msg_buffers[i].type = COMMAND;
3485 priv->msg_buffers[i].info.c_struct.cmd = 3485 priv->msg_buffers[i].info.c_struct.cmd =
3486 (struct ipw2100_cmd_header *)v; 3486 (struct ipw2100_cmd_header *)v;
3487 priv->msg_buffers[i].info.c_struct.cmd_phys = p; 3487 priv->msg_buffers[i].info.c_struct.cmd_phys = p;
3488 } 3488 }
3489 3489
3490 if (i == IPW_COMMAND_POOL_SIZE) 3490 if (i == IPW_COMMAND_POOL_SIZE)
3491 return 0; 3491 return 0;
3492 3492
3493 for (j = 0; j < i; j++) { 3493 for (j = 0; j < i; j++) {
3494 pci_free_consistent(priv->pci_dev, 3494 pci_free_consistent(priv->pci_dev,
3495 sizeof(struct ipw2100_cmd_header), 3495 sizeof(struct ipw2100_cmd_header),
3496 priv->msg_buffers[j].info.c_struct.cmd, 3496 priv->msg_buffers[j].info.c_struct.cmd,
3497 priv->msg_buffers[j].info.c_struct. 3497 priv->msg_buffers[j].info.c_struct.
3498 cmd_phys); 3498 cmd_phys);
3499 } 3499 }
3500 3500
3501 kfree(priv->msg_buffers); 3501 kfree(priv->msg_buffers);
3502 priv->msg_buffers = NULL; 3502 priv->msg_buffers = NULL;
3503 3503
3504 return err; 3504 return err;
3505 } 3505 }
3506 3506
3507 static int ipw2100_msg_initialize(struct ipw2100_priv *priv) 3507 static int ipw2100_msg_initialize(struct ipw2100_priv *priv)
3508 { 3508 {
3509 int i; 3509 int i;
3510 3510
3511 INIT_LIST_HEAD(&priv->msg_free_list); 3511 INIT_LIST_HEAD(&priv->msg_free_list);
3512 INIT_LIST_HEAD(&priv->msg_pend_list); 3512 INIT_LIST_HEAD(&priv->msg_pend_list);
3513 3513
3514 for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++) 3514 for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++)
3515 list_add_tail(&priv->msg_buffers[i].list, &priv->msg_free_list); 3515 list_add_tail(&priv->msg_buffers[i].list, &priv->msg_free_list);
3516 SET_STAT(&priv->msg_free_stat, i); 3516 SET_STAT(&priv->msg_free_stat, i);
3517 3517
3518 return 0; 3518 return 0;
3519 } 3519 }
3520 3520
3521 static void ipw2100_msg_free(struct ipw2100_priv *priv) 3521 static void ipw2100_msg_free(struct ipw2100_priv *priv)
3522 { 3522 {
3523 int i; 3523 int i;
3524 3524
3525 if (!priv->msg_buffers) 3525 if (!priv->msg_buffers)
3526 return; 3526 return;
3527 3527
3528 for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++) { 3528 for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++) {
3529 pci_free_consistent(priv->pci_dev, 3529 pci_free_consistent(priv->pci_dev,
3530 sizeof(struct ipw2100_cmd_header), 3530 sizeof(struct ipw2100_cmd_header),
3531 priv->msg_buffers[i].info.c_struct.cmd, 3531 priv->msg_buffers[i].info.c_struct.cmd,
3532 priv->msg_buffers[i].info.c_struct. 3532 priv->msg_buffers[i].info.c_struct.
3533 cmd_phys); 3533 cmd_phys);
3534 } 3534 }
3535 3535
3536 kfree(priv->msg_buffers); 3536 kfree(priv->msg_buffers);
3537 priv->msg_buffers = NULL; 3537 priv->msg_buffers = NULL;
3538 } 3538 }
3539 3539
3540 static ssize_t show_pci(struct device *d, struct device_attribute *attr, 3540 static ssize_t show_pci(struct device *d, struct device_attribute *attr,
3541 char *buf) 3541 char *buf)
3542 { 3542 {
3543 struct pci_dev *pci_dev = container_of(d, struct pci_dev, dev); 3543 struct pci_dev *pci_dev = container_of(d, struct pci_dev, dev);
3544 char *out = buf; 3544 char *out = buf;
3545 int i, j; 3545 int i, j;
3546 u32 val; 3546 u32 val;
3547 3547
3548 for (i = 0; i < 16; i++) { 3548 for (i = 0; i < 16; i++) {
3549 out += sprintf(out, "[%08X] ", i * 16); 3549 out += sprintf(out, "[%08X] ", i * 16);
3550 for (j = 0; j < 16; j += 4) { 3550 for (j = 0; j < 16; j += 4) {
3551 pci_read_config_dword(pci_dev, i * 16 + j, &val); 3551 pci_read_config_dword(pci_dev, i * 16 + j, &val);
3552 out += sprintf(out, "%08X ", val); 3552 out += sprintf(out, "%08X ", val);
3553 } 3553 }
3554 out += sprintf(out, "\n"); 3554 out += sprintf(out, "\n");
3555 } 3555 }
3556 3556
3557 return out - buf; 3557 return out - buf;
3558 } 3558 }
3559 3559
3560 static DEVICE_ATTR(pci, S_IRUGO, show_pci, NULL); 3560 static DEVICE_ATTR(pci, S_IRUGO, show_pci, NULL);
3561 3561
3562 static ssize_t show_cfg(struct device *d, struct device_attribute *attr, 3562 static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
3563 char *buf) 3563 char *buf)
3564 { 3564 {
3565 struct ipw2100_priv *p = dev_get_drvdata(d); 3565 struct ipw2100_priv *p = dev_get_drvdata(d);
3566 return sprintf(buf, "0x%08x\n", (int)p->config); 3566 return sprintf(buf, "0x%08x\n", (int)p->config);
3567 } 3567 }
3568 3568
3569 static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL); 3569 static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL);
3570 3570
3571 static ssize_t show_status(struct device *d, struct device_attribute *attr, 3571 static ssize_t show_status(struct device *d, struct device_attribute *attr,
3572 char *buf) 3572 char *buf)
3573 { 3573 {
3574 struct ipw2100_priv *p = dev_get_drvdata(d); 3574 struct ipw2100_priv *p = dev_get_drvdata(d);
3575 return sprintf(buf, "0x%08x\n", (int)p->status); 3575 return sprintf(buf, "0x%08x\n", (int)p->status);
3576 } 3576 }
3577 3577
3578 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL); 3578 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
3579 3579
3580 static ssize_t show_capability(struct device *d, struct device_attribute *attr, 3580 static ssize_t show_capability(struct device *d, struct device_attribute *attr,
3581 char *buf) 3581 char *buf)
3582 { 3582 {
3583 struct ipw2100_priv *p = dev_get_drvdata(d); 3583 struct ipw2100_priv *p = dev_get_drvdata(d);
3584 return sprintf(buf, "0x%08x\n", (int)p->capability); 3584 return sprintf(buf, "0x%08x\n", (int)p->capability);
3585 } 3585 }
3586 3586
3587 static DEVICE_ATTR(capability, S_IRUGO, show_capability, NULL); 3587 static DEVICE_ATTR(capability, S_IRUGO, show_capability, NULL);
3588 3588
3589 #define IPW2100_REG(x) { IPW_ ##x, #x } 3589 #define IPW2100_REG(x) { IPW_ ##x, #x }
3590 static const struct { 3590 static const struct {
3591 u32 addr; 3591 u32 addr;
3592 const char *name; 3592 const char *name;
3593 } hw_data[] = { 3593 } hw_data[] = {
3594 IPW2100_REG(REG_GP_CNTRL), 3594 IPW2100_REG(REG_GP_CNTRL),
3595 IPW2100_REG(REG_GPIO), 3595 IPW2100_REG(REG_GPIO),
3596 IPW2100_REG(REG_INTA), 3596 IPW2100_REG(REG_INTA),
3597 IPW2100_REG(REG_INTA_MASK), IPW2100_REG(REG_RESET_REG),}; 3597 IPW2100_REG(REG_INTA_MASK), IPW2100_REG(REG_RESET_REG),};
3598 #define IPW2100_NIC(x, s) { x, #x, s } 3598 #define IPW2100_NIC(x, s) { x, #x, s }
3599 static const struct { 3599 static const struct {
3600 u32 addr; 3600 u32 addr;
3601 const char *name; 3601 const char *name;
3602 size_t size; 3602 size_t size;
3603 } nic_data[] = { 3603 } nic_data[] = {
3604 IPW2100_NIC(IPW2100_CONTROL_REG, 2), 3604 IPW2100_NIC(IPW2100_CONTROL_REG, 2),
3605 IPW2100_NIC(0x210014, 1), IPW2100_NIC(0x210000, 1),}; 3605 IPW2100_NIC(0x210014, 1), IPW2100_NIC(0x210000, 1),};
3606 #define IPW2100_ORD(x, d) { IPW_ORD_ ##x, #x, d } 3606 #define IPW2100_ORD(x, d) { IPW_ORD_ ##x, #x, d }
3607 static const struct { 3607 static const struct {
3608 u8 index; 3608 u8 index;
3609 const char *name; 3609 const char *name;
3610 const char *desc; 3610 const char *desc;
3611 } ord_data[] = { 3611 } ord_data[] = {
3612 IPW2100_ORD(STAT_TX_HOST_REQUESTS, "requested Host Tx's (MSDU)"), 3612 IPW2100_ORD(STAT_TX_HOST_REQUESTS, "requested Host Tx's (MSDU)"),
3613 IPW2100_ORD(STAT_TX_HOST_COMPLETE, 3613 IPW2100_ORD(STAT_TX_HOST_COMPLETE,
3614 "successful Host Tx's (MSDU)"), 3614 "successful Host Tx's (MSDU)"),
3615 IPW2100_ORD(STAT_TX_DIR_DATA, 3615 IPW2100_ORD(STAT_TX_DIR_DATA,
3616 "successful Directed Tx's (MSDU)"), 3616 "successful Directed Tx's (MSDU)"),
3617 IPW2100_ORD(STAT_TX_DIR_DATA1, 3617 IPW2100_ORD(STAT_TX_DIR_DATA1,
3618 "successful Directed Tx's (MSDU) @ 1MB"), 3618 "successful Directed Tx's (MSDU) @ 1MB"),
3619 IPW2100_ORD(STAT_TX_DIR_DATA2, 3619 IPW2100_ORD(STAT_TX_DIR_DATA2,
3620 "successful Directed Tx's (MSDU) @ 2MB"), 3620 "successful Directed Tx's (MSDU) @ 2MB"),
3621 IPW2100_ORD(STAT_TX_DIR_DATA5_5, 3621 IPW2100_ORD(STAT_TX_DIR_DATA5_5,
3622 "successful Directed Tx's (MSDU) @ 5_5MB"), 3622 "successful Directed Tx's (MSDU) @ 5_5MB"),
3623 IPW2100_ORD(STAT_TX_DIR_DATA11, 3623 IPW2100_ORD(STAT_TX_DIR_DATA11,
3624 "successful Directed Tx's (MSDU) @ 11MB"), 3624 "successful Directed Tx's (MSDU) @ 11MB"),
3625 IPW2100_ORD(STAT_TX_NODIR_DATA1, 3625 IPW2100_ORD(STAT_TX_NODIR_DATA1,
3626 "successful Non_Directed Tx's (MSDU) @ 1MB"), 3626 "successful Non_Directed Tx's (MSDU) @ 1MB"),
3627 IPW2100_ORD(STAT_TX_NODIR_DATA2, 3627 IPW2100_ORD(STAT_TX_NODIR_DATA2,
3628 "successful Non_Directed Tx's (MSDU) @ 2MB"), 3628 "successful Non_Directed Tx's (MSDU) @ 2MB"),
3629 IPW2100_ORD(STAT_TX_NODIR_DATA5_5, 3629 IPW2100_ORD(STAT_TX_NODIR_DATA5_5,
3630 "successful Non_Directed Tx's (MSDU) @ 5.5MB"), 3630 "successful Non_Directed Tx's (MSDU) @ 5.5MB"),
3631 IPW2100_ORD(STAT_TX_NODIR_DATA11, 3631 IPW2100_ORD(STAT_TX_NODIR_DATA11,
3632 "successful Non_Directed Tx's (MSDU) @ 11MB"), 3632 "successful Non_Directed Tx's (MSDU) @ 11MB"),
3633 IPW2100_ORD(STAT_NULL_DATA, "successful NULL data Tx's"), 3633 IPW2100_ORD(STAT_NULL_DATA, "successful NULL data Tx's"),
3634 IPW2100_ORD(STAT_TX_RTS, "successful Tx RTS"), 3634 IPW2100_ORD(STAT_TX_RTS, "successful Tx RTS"),
3635 IPW2100_ORD(STAT_TX_CTS, "successful Tx CTS"), 3635 IPW2100_ORD(STAT_TX_CTS, "successful Tx CTS"),
3636 IPW2100_ORD(STAT_TX_ACK, "successful Tx ACK"), 3636 IPW2100_ORD(STAT_TX_ACK, "successful Tx ACK"),
3637 IPW2100_ORD(STAT_TX_ASSN, "successful Association Tx's"), 3637 IPW2100_ORD(STAT_TX_ASSN, "successful Association Tx's"),
3638 IPW2100_ORD(STAT_TX_ASSN_RESP, 3638 IPW2100_ORD(STAT_TX_ASSN_RESP,
3639 "successful Association response Tx's"), 3639 "successful Association response Tx's"),
3640 IPW2100_ORD(STAT_TX_REASSN, 3640 IPW2100_ORD(STAT_TX_REASSN,
3641 "successful Reassociation Tx's"), 3641 "successful Reassociation Tx's"),
3642 IPW2100_ORD(STAT_TX_REASSN_RESP, 3642 IPW2100_ORD(STAT_TX_REASSN_RESP,
3643 "successful Reassociation response Tx's"), 3643 "successful Reassociation response Tx's"),
3644 IPW2100_ORD(STAT_TX_PROBE, 3644 IPW2100_ORD(STAT_TX_PROBE,
3645 "probes successfully transmitted"), 3645 "probes successfully transmitted"),
3646 IPW2100_ORD(STAT_TX_PROBE_RESP, 3646 IPW2100_ORD(STAT_TX_PROBE_RESP,
3647 "probe responses successfully transmitted"), 3647 "probe responses successfully transmitted"),
3648 IPW2100_ORD(STAT_TX_BEACON, "tx beacon"), 3648 IPW2100_ORD(STAT_TX_BEACON, "tx beacon"),
3649 IPW2100_ORD(STAT_TX_ATIM, "Tx ATIM"), 3649 IPW2100_ORD(STAT_TX_ATIM, "Tx ATIM"),
3650 IPW2100_ORD(STAT_TX_DISASSN, 3650 IPW2100_ORD(STAT_TX_DISASSN,
3651 "successful Disassociation TX"), 3651 "successful Disassociation TX"),
3652 IPW2100_ORD(STAT_TX_AUTH, "successful Authentication Tx"), 3652 IPW2100_ORD(STAT_TX_AUTH, "successful Authentication Tx"),
3653 IPW2100_ORD(STAT_TX_DEAUTH, 3653 IPW2100_ORD(STAT_TX_DEAUTH,
3654 "successful Deauthentication TX"), 3654 "successful Deauthentication TX"),
3655 IPW2100_ORD(STAT_TX_TOTAL_BYTES, 3655 IPW2100_ORD(STAT_TX_TOTAL_BYTES,
3656 "Total successful Tx data bytes"), 3656 "Total successful Tx data bytes"),
3657 IPW2100_ORD(STAT_TX_RETRIES, "Tx retries"), 3657 IPW2100_ORD(STAT_TX_RETRIES, "Tx retries"),
3658 IPW2100_ORD(STAT_TX_RETRY1, "Tx retries at 1MBPS"), 3658 IPW2100_ORD(STAT_TX_RETRY1, "Tx retries at 1MBPS"),
3659 IPW2100_ORD(STAT_TX_RETRY2, "Tx retries at 2MBPS"), 3659 IPW2100_ORD(STAT_TX_RETRY2, "Tx retries at 2MBPS"),
3660 IPW2100_ORD(STAT_TX_RETRY5_5, "Tx retries at 5.5MBPS"), 3660 IPW2100_ORD(STAT_TX_RETRY5_5, "Tx retries at 5.5MBPS"),
3661 IPW2100_ORD(STAT_TX_RETRY11, "Tx retries at 11MBPS"), 3661 IPW2100_ORD(STAT_TX_RETRY11, "Tx retries at 11MBPS"),
3662 IPW2100_ORD(STAT_TX_FAILURES, "Tx Failures"), 3662 IPW2100_ORD(STAT_TX_FAILURES, "Tx Failures"),
3663 IPW2100_ORD(STAT_TX_MAX_TRIES_IN_HOP, 3663 IPW2100_ORD(STAT_TX_MAX_TRIES_IN_HOP,
3664 "times max tries in a hop failed"), 3664 "times max tries in a hop failed"),
3665 IPW2100_ORD(STAT_TX_DISASSN_FAIL, 3665 IPW2100_ORD(STAT_TX_DISASSN_FAIL,
3666 "times disassociation failed"), 3666 "times disassociation failed"),
3667 IPW2100_ORD(STAT_TX_ERR_CTS, "missed/bad CTS frames"), 3667 IPW2100_ORD(STAT_TX_ERR_CTS, "missed/bad CTS frames"),
3668 IPW2100_ORD(STAT_TX_ERR_ACK, "tx err due to acks"), 3668 IPW2100_ORD(STAT_TX_ERR_ACK, "tx err due to acks"),
3669 IPW2100_ORD(STAT_RX_HOST, "packets passed to host"), 3669 IPW2100_ORD(STAT_RX_HOST, "packets passed to host"),
3670 IPW2100_ORD(STAT_RX_DIR_DATA, "directed packets"), 3670 IPW2100_ORD(STAT_RX_DIR_DATA, "directed packets"),
3671 IPW2100_ORD(STAT_RX_DIR_DATA1, "directed packets at 1MB"), 3671 IPW2100_ORD(STAT_RX_DIR_DATA1, "directed packets at 1MB"),
3672 IPW2100_ORD(STAT_RX_DIR_DATA2, "directed packets at 2MB"), 3672 IPW2100_ORD(STAT_RX_DIR_DATA2, "directed packets at 2MB"),
3673 IPW2100_ORD(STAT_RX_DIR_DATA5_5, 3673 IPW2100_ORD(STAT_RX_DIR_DATA5_5,
3674 "directed packets at 5.5MB"), 3674 "directed packets at 5.5MB"),
3675 IPW2100_ORD(STAT_RX_DIR_DATA11, "directed packets at 11MB"), 3675 IPW2100_ORD(STAT_RX_DIR_DATA11, "directed packets at 11MB"),
3676 IPW2100_ORD(STAT_RX_NODIR_DATA, "nondirected packets"), 3676 IPW2100_ORD(STAT_RX_NODIR_DATA, "nondirected packets"),
3677 IPW2100_ORD(STAT_RX_NODIR_DATA1, 3677 IPW2100_ORD(STAT_RX_NODIR_DATA1,
3678 "nondirected packets at 1MB"), 3678 "nondirected packets at 1MB"),
3679 IPW2100_ORD(STAT_RX_NODIR_DATA2, 3679 IPW2100_ORD(STAT_RX_NODIR_DATA2,
3680 "nondirected packets at 2MB"), 3680 "nondirected packets at 2MB"),
3681 IPW2100_ORD(STAT_RX_NODIR_DATA5_5, 3681 IPW2100_ORD(STAT_RX_NODIR_DATA5_5,
3682 "nondirected packets at 5.5MB"), 3682 "nondirected packets at 5.5MB"),
3683 IPW2100_ORD(STAT_RX_NODIR_DATA11, 3683 IPW2100_ORD(STAT_RX_NODIR_DATA11,
3684 "nondirected packets at 11MB"), 3684 "nondirected packets at 11MB"),
3685 IPW2100_ORD(STAT_RX_NULL_DATA, "null data rx's"), 3685 IPW2100_ORD(STAT_RX_NULL_DATA, "null data rx's"),
3686 IPW2100_ORD(STAT_RX_RTS, "Rx RTS"), IPW2100_ORD(STAT_RX_CTS, 3686 IPW2100_ORD(STAT_RX_RTS, "Rx RTS"), IPW2100_ORD(STAT_RX_CTS,
3687 "Rx CTS"), 3687 "Rx CTS"),
3688 IPW2100_ORD(STAT_RX_ACK, "Rx ACK"), 3688 IPW2100_ORD(STAT_RX_ACK, "Rx ACK"),
3689 IPW2100_ORD(STAT_RX_CFEND, "Rx CF End"), 3689 IPW2100_ORD(STAT_RX_CFEND, "Rx CF End"),
3690 IPW2100_ORD(STAT_RX_CFEND_ACK, "Rx CF End + CF Ack"), 3690 IPW2100_ORD(STAT_RX_CFEND_ACK, "Rx CF End + CF Ack"),
3691 IPW2100_ORD(STAT_RX_ASSN, "Association Rx's"), 3691 IPW2100_ORD(STAT_RX_ASSN, "Association Rx's"),
3692 IPW2100_ORD(STAT_RX_ASSN_RESP, "Association response Rx's"), 3692 IPW2100_ORD(STAT_RX_ASSN_RESP, "Association response Rx's"),
3693 IPW2100_ORD(STAT_RX_REASSN, "Reassociation Rx's"), 3693 IPW2100_ORD(STAT_RX_REASSN, "Reassociation Rx's"),
3694 IPW2100_ORD(STAT_RX_REASSN_RESP, 3694 IPW2100_ORD(STAT_RX_REASSN_RESP,
3695 "Reassociation response Rx's"), 3695 "Reassociation response Rx's"),
3696 IPW2100_ORD(STAT_RX_PROBE, "probe Rx's"), 3696 IPW2100_ORD(STAT_RX_PROBE, "probe Rx's"),
3697 IPW2100_ORD(STAT_RX_PROBE_RESP, "probe response Rx's"), 3697 IPW2100_ORD(STAT_RX_PROBE_RESP, "probe response Rx's"),
3698 IPW2100_ORD(STAT_RX_BEACON, "Rx beacon"), 3698 IPW2100_ORD(STAT_RX_BEACON, "Rx beacon"),
3699 IPW2100_ORD(STAT_RX_ATIM, "Rx ATIM"), 3699 IPW2100_ORD(STAT_RX_ATIM, "Rx ATIM"),
3700 IPW2100_ORD(STAT_RX_DISASSN, "disassociation Rx"), 3700 IPW2100_ORD(STAT_RX_DISASSN, "disassociation Rx"),
3701 IPW2100_ORD(STAT_RX_AUTH, "authentication Rx"), 3701 IPW2100_ORD(STAT_RX_AUTH, "authentication Rx"),
3702 IPW2100_ORD(STAT_RX_DEAUTH, "deauthentication Rx"), 3702 IPW2100_ORD(STAT_RX_DEAUTH, "deauthentication Rx"),
3703 IPW2100_ORD(STAT_RX_TOTAL_BYTES, 3703 IPW2100_ORD(STAT_RX_TOTAL_BYTES,
3704 "Total rx data bytes received"), 3704 "Total rx data bytes received"),
3705 IPW2100_ORD(STAT_RX_ERR_CRC, "packets with Rx CRC error"), 3705 IPW2100_ORD(STAT_RX_ERR_CRC, "packets with Rx CRC error"),
3706 IPW2100_ORD(STAT_RX_ERR_CRC1, "Rx CRC errors at 1MB"), 3706 IPW2100_ORD(STAT_RX_ERR_CRC1, "Rx CRC errors at 1MB"),
3707 IPW2100_ORD(STAT_RX_ERR_CRC2, "Rx CRC errors at 2MB"), 3707 IPW2100_ORD(STAT_RX_ERR_CRC2, "Rx CRC errors at 2MB"),
3708 IPW2100_ORD(STAT_RX_ERR_CRC5_5, "Rx CRC errors at 5.5MB"), 3708 IPW2100_ORD(STAT_RX_ERR_CRC5_5, "Rx CRC errors at 5.5MB"),
3709 IPW2100_ORD(STAT_RX_ERR_CRC11, "Rx CRC errors at 11MB"), 3709 IPW2100_ORD(STAT_RX_ERR_CRC11, "Rx CRC errors at 11MB"),
3710 IPW2100_ORD(STAT_RX_DUPLICATE1, 3710 IPW2100_ORD(STAT_RX_DUPLICATE1,
3711 "duplicate rx packets at 1MB"), 3711 "duplicate rx packets at 1MB"),
3712 IPW2100_ORD(STAT_RX_DUPLICATE2, 3712 IPW2100_ORD(STAT_RX_DUPLICATE2,
3713 "duplicate rx packets at 2MB"), 3713 "duplicate rx packets at 2MB"),
3714 IPW2100_ORD(STAT_RX_DUPLICATE5_5, 3714 IPW2100_ORD(STAT_RX_DUPLICATE5_5,
3715 "duplicate rx packets at 5.5MB"), 3715 "duplicate rx packets at 5.5MB"),
3716 IPW2100_ORD(STAT_RX_DUPLICATE11, 3716 IPW2100_ORD(STAT_RX_DUPLICATE11,
3717 "duplicate rx packets at 11MB"), 3717 "duplicate rx packets at 11MB"),
3718 IPW2100_ORD(STAT_RX_DUPLICATE, "duplicate rx packets"), 3718 IPW2100_ORD(STAT_RX_DUPLICATE, "duplicate rx packets"),
3719 IPW2100_ORD(PERS_DB_LOCK, "locking fw permanent db"), 3719 IPW2100_ORD(PERS_DB_LOCK, "locking fw permanent db"),
3720 IPW2100_ORD(PERS_DB_SIZE, "size of fw permanent db"), 3720 IPW2100_ORD(PERS_DB_SIZE, "size of fw permanent db"),
3721 IPW2100_ORD(PERS_DB_ADDR, "address of fw permanent db"), 3721 IPW2100_ORD(PERS_DB_ADDR, "address of fw permanent db"),
3722 IPW2100_ORD(STAT_RX_INVALID_PROTOCOL, 3722 IPW2100_ORD(STAT_RX_INVALID_PROTOCOL,
3723 "rx frames with invalid protocol"), 3723 "rx frames with invalid protocol"),
3724 IPW2100_ORD(SYS_BOOT_TIME, "Boot time"), 3724 IPW2100_ORD(SYS_BOOT_TIME, "Boot time"),
3725 IPW2100_ORD(STAT_RX_NO_BUFFER, 3725 IPW2100_ORD(STAT_RX_NO_BUFFER,
3726 "rx frames rejected due to no buffer"), 3726 "rx frames rejected due to no buffer"),
3727 IPW2100_ORD(STAT_RX_MISSING_FRAG, 3727 IPW2100_ORD(STAT_RX_MISSING_FRAG,
3728 "rx frames dropped due to missing fragment"), 3728 "rx frames dropped due to missing fragment"),
3729 IPW2100_ORD(STAT_RX_ORPHAN_FRAG, 3729 IPW2100_ORD(STAT_RX_ORPHAN_FRAG,
3730 "rx frames dropped due to non-sequential fragment"), 3730 "rx frames dropped due to non-sequential fragment"),
3731 IPW2100_ORD(STAT_RX_ORPHAN_FRAME, 3731 IPW2100_ORD(STAT_RX_ORPHAN_FRAME,
3732 "rx frames dropped due to unmatched 1st frame"), 3732 "rx frames dropped due to unmatched 1st frame"),
3733 IPW2100_ORD(STAT_RX_FRAG_AGEOUT, 3733 IPW2100_ORD(STAT_RX_FRAG_AGEOUT,
3734 "rx frames dropped due to uncompleted frame"), 3734 "rx frames dropped due to uncompleted frame"),
3735 IPW2100_ORD(STAT_RX_ICV_ERRORS, 3735 IPW2100_ORD(STAT_RX_ICV_ERRORS,
3736 "ICV errors during decryption"), 3736 "ICV errors during decryption"),
3737 IPW2100_ORD(STAT_PSP_SUSPENSION, "times adapter suspended"), 3737 IPW2100_ORD(STAT_PSP_SUSPENSION, "times adapter suspended"),
3738 IPW2100_ORD(STAT_PSP_BCN_TIMEOUT, "beacon timeout"), 3738 IPW2100_ORD(STAT_PSP_BCN_TIMEOUT, "beacon timeout"),
3739 IPW2100_ORD(STAT_PSP_POLL_TIMEOUT, 3739 IPW2100_ORD(STAT_PSP_POLL_TIMEOUT,
3740 "poll response timeouts"), 3740 "poll response timeouts"),
3741 IPW2100_ORD(STAT_PSP_NONDIR_TIMEOUT, 3741 IPW2100_ORD(STAT_PSP_NONDIR_TIMEOUT,
3742 "timeouts waiting for last {broad,multi}cast pkt"), 3742 "timeouts waiting for last {broad,multi}cast pkt"),
3743 IPW2100_ORD(STAT_PSP_RX_DTIMS, "PSP DTIMs received"), 3743 IPW2100_ORD(STAT_PSP_RX_DTIMS, "PSP DTIMs received"),
3744 IPW2100_ORD(STAT_PSP_RX_TIMS, "PSP TIMs received"), 3744 IPW2100_ORD(STAT_PSP_RX_TIMS, "PSP TIMs received"),
3745 IPW2100_ORD(STAT_PSP_STATION_ID, "PSP Station ID"), 3745 IPW2100_ORD(STAT_PSP_STATION_ID, "PSP Station ID"),
3746 IPW2100_ORD(LAST_ASSN_TIME, "RTC time of last association"), 3746 IPW2100_ORD(LAST_ASSN_TIME, "RTC time of last association"),
3747 IPW2100_ORD(STAT_PERCENT_MISSED_BCNS, 3747 IPW2100_ORD(STAT_PERCENT_MISSED_BCNS,
3748 "current calculation of % missed beacons"), 3748 "current calculation of % missed beacons"),
3749 IPW2100_ORD(STAT_PERCENT_RETRIES, 3749 IPW2100_ORD(STAT_PERCENT_RETRIES,
3750 "current calculation of % missed tx retries"), 3750 "current calculation of % missed tx retries"),
3751 IPW2100_ORD(ASSOCIATED_AP_PTR, 3751 IPW2100_ORD(ASSOCIATED_AP_PTR,
3752 "0 if not associated, else pointer to AP table entry"), 3752 "0 if not associated, else pointer to AP table entry"),
3753 IPW2100_ORD(AVAILABLE_AP_CNT, 3753 IPW2100_ORD(AVAILABLE_AP_CNT,
3754 "AP's decsribed in the AP table"), 3754 "AP's decsribed in the AP table"),
3755 IPW2100_ORD(AP_LIST_PTR, "Ptr to list of available APs"), 3755 IPW2100_ORD(AP_LIST_PTR, "Ptr to list of available APs"),
3756 IPW2100_ORD(STAT_AP_ASSNS, "associations"), 3756 IPW2100_ORD(STAT_AP_ASSNS, "associations"),
3757 IPW2100_ORD(STAT_ASSN_FAIL, "association failures"), 3757 IPW2100_ORD(STAT_ASSN_FAIL, "association failures"),
3758 IPW2100_ORD(STAT_ASSN_RESP_FAIL, 3758 IPW2100_ORD(STAT_ASSN_RESP_FAIL,
3759 "failures due to response fail"), 3759 "failures due to response fail"),
3760 IPW2100_ORD(STAT_FULL_SCANS, "full scans"), 3760 IPW2100_ORD(STAT_FULL_SCANS, "full scans"),
3761 IPW2100_ORD(CARD_DISABLED, "Card Disabled"), 3761 IPW2100_ORD(CARD_DISABLED, "Card Disabled"),
3762 IPW2100_ORD(STAT_ROAM_INHIBIT, 3762 IPW2100_ORD(STAT_ROAM_INHIBIT,
3763 "times roaming was inhibited due to activity"), 3763 "times roaming was inhibited due to activity"),
3764 IPW2100_ORD(RSSI_AT_ASSN, 3764 IPW2100_ORD(RSSI_AT_ASSN,
3765 "RSSI of associated AP at time of association"), 3765 "RSSI of associated AP at time of association"),
3766 IPW2100_ORD(STAT_ASSN_CAUSE1, 3766 IPW2100_ORD(STAT_ASSN_CAUSE1,
3767 "reassociation: no probe response or TX on hop"), 3767 "reassociation: no probe response or TX on hop"),
3768 IPW2100_ORD(STAT_ASSN_CAUSE2, 3768 IPW2100_ORD(STAT_ASSN_CAUSE2,
3769 "reassociation: poor tx/rx quality"), 3769 "reassociation: poor tx/rx quality"),
3770 IPW2100_ORD(STAT_ASSN_CAUSE3, 3770 IPW2100_ORD(STAT_ASSN_CAUSE3,
3771 "reassociation: tx/rx quality (excessive AP load"), 3771 "reassociation: tx/rx quality (excessive AP load"),
3772 IPW2100_ORD(STAT_ASSN_CAUSE4, 3772 IPW2100_ORD(STAT_ASSN_CAUSE4,
3773 "reassociation: AP RSSI level"), 3773 "reassociation: AP RSSI level"),
3774 IPW2100_ORD(STAT_ASSN_CAUSE5, 3774 IPW2100_ORD(STAT_ASSN_CAUSE5,
3775 "reassociations due to load leveling"), 3775 "reassociations due to load leveling"),
3776 IPW2100_ORD(STAT_AUTH_FAIL, "times authentication failed"), 3776 IPW2100_ORD(STAT_AUTH_FAIL, "times authentication failed"),
3777 IPW2100_ORD(STAT_AUTH_RESP_FAIL, 3777 IPW2100_ORD(STAT_AUTH_RESP_FAIL,
3778 "times authentication response failed"), 3778 "times authentication response failed"),
3779 IPW2100_ORD(STATION_TABLE_CNT, 3779 IPW2100_ORD(STATION_TABLE_CNT,
3780 "entries in association table"), 3780 "entries in association table"),
3781 IPW2100_ORD(RSSI_AVG_CURR, "Current avg RSSI"), 3781 IPW2100_ORD(RSSI_AVG_CURR, "Current avg RSSI"),
3782 IPW2100_ORD(POWER_MGMT_MODE, "Power mode - 0=CAM, 1=PSP"), 3782 IPW2100_ORD(POWER_MGMT_MODE, "Power mode - 0=CAM, 1=PSP"),
3783 IPW2100_ORD(COUNTRY_CODE, 3783 IPW2100_ORD(COUNTRY_CODE,
3784 "IEEE country code as recv'd from beacon"), 3784 "IEEE country code as recv'd from beacon"),
3785 IPW2100_ORD(COUNTRY_CHANNELS, 3785 IPW2100_ORD(COUNTRY_CHANNELS,
3786 "channels suported by country"), 3786 "channels suported by country"),
3787 IPW2100_ORD(RESET_CNT, "adapter resets (warm)"), 3787 IPW2100_ORD(RESET_CNT, "adapter resets (warm)"),
3788 IPW2100_ORD(BEACON_INTERVAL, "Beacon interval"), 3788 IPW2100_ORD(BEACON_INTERVAL, "Beacon interval"),
3789 IPW2100_ORD(ANTENNA_DIVERSITY, 3789 IPW2100_ORD(ANTENNA_DIVERSITY,
3790 "TRUE if antenna diversity is disabled"), 3790 "TRUE if antenna diversity is disabled"),
3791 IPW2100_ORD(DTIM_PERIOD, "beacon intervals between DTIMs"), 3791 IPW2100_ORD(DTIM_PERIOD, "beacon intervals between DTIMs"),
3792 IPW2100_ORD(OUR_FREQ, 3792 IPW2100_ORD(OUR_FREQ,
3793 "current radio freq lower digits - channel ID"), 3793 "current radio freq lower digits - channel ID"),
3794 IPW2100_ORD(RTC_TIME, "current RTC time"), 3794 IPW2100_ORD(RTC_TIME, "current RTC time"),
3795 IPW2100_ORD(PORT_TYPE, "operating mode"), 3795 IPW2100_ORD(PORT_TYPE, "operating mode"),
3796 IPW2100_ORD(CURRENT_TX_RATE, "current tx rate"), 3796 IPW2100_ORD(CURRENT_TX_RATE, "current tx rate"),
3797 IPW2100_ORD(SUPPORTED_RATES, "supported tx rates"), 3797 IPW2100_ORD(SUPPORTED_RATES, "supported tx rates"),
3798 IPW2100_ORD(ATIM_WINDOW, "current ATIM Window"), 3798 IPW2100_ORD(ATIM_WINDOW, "current ATIM Window"),
3799 IPW2100_ORD(BASIC_RATES, "basic tx rates"), 3799 IPW2100_ORD(BASIC_RATES, "basic tx rates"),
3800 IPW2100_ORD(NIC_HIGHEST_RATE, "NIC highest tx rate"), 3800 IPW2100_ORD(NIC_HIGHEST_RATE, "NIC highest tx rate"),
3801 IPW2100_ORD(AP_HIGHEST_RATE, "AP highest tx rate"), 3801 IPW2100_ORD(AP_HIGHEST_RATE, "AP highest tx rate"),
3802 IPW2100_ORD(CAPABILITIES, 3802 IPW2100_ORD(CAPABILITIES,
3803 "Management frame capability field"), 3803 "Management frame capability field"),
3804 IPW2100_ORD(AUTH_TYPE, "Type of authentication"), 3804 IPW2100_ORD(AUTH_TYPE, "Type of authentication"),
3805 IPW2100_ORD(RADIO_TYPE, "Adapter card platform type"), 3805 IPW2100_ORD(RADIO_TYPE, "Adapter card platform type"),
3806 IPW2100_ORD(RTS_THRESHOLD, 3806 IPW2100_ORD(RTS_THRESHOLD,
3807 "Min packet length for RTS handshaking"), 3807 "Min packet length for RTS handshaking"),
3808 IPW2100_ORD(INT_MODE, "International mode"), 3808 IPW2100_ORD(INT_MODE, "International mode"),
3809 IPW2100_ORD(FRAGMENTATION_THRESHOLD, 3809 IPW2100_ORD(FRAGMENTATION_THRESHOLD,
3810 "protocol frag threshold"), 3810 "protocol frag threshold"),
3811 IPW2100_ORD(EEPROM_SRAM_DB_BLOCK_START_ADDRESS, 3811 IPW2100_ORD(EEPROM_SRAM_DB_BLOCK_START_ADDRESS,
3812 "EEPROM offset in SRAM"), 3812 "EEPROM offset in SRAM"),
3813 IPW2100_ORD(EEPROM_SRAM_DB_BLOCK_SIZE, 3813 IPW2100_ORD(EEPROM_SRAM_DB_BLOCK_SIZE,
3814 "EEPROM size in SRAM"), 3814 "EEPROM size in SRAM"),
3815 IPW2100_ORD(EEPROM_SKU_CAPABILITY, "EEPROM SKU Capability"), 3815 IPW2100_ORD(EEPROM_SKU_CAPABILITY, "EEPROM SKU Capability"),
3816 IPW2100_ORD(EEPROM_IBSS_11B_CHANNELS, 3816 IPW2100_ORD(EEPROM_IBSS_11B_CHANNELS,
3817 "EEPROM IBSS 11b channel set"), 3817 "EEPROM IBSS 11b channel set"),
3818 IPW2100_ORD(MAC_VERSION, "MAC Version"), 3818 IPW2100_ORD(MAC_VERSION, "MAC Version"),
3819 IPW2100_ORD(MAC_REVISION, "MAC Revision"), 3819 IPW2100_ORD(MAC_REVISION, "MAC Revision"),
3820 IPW2100_ORD(RADIO_VERSION, "Radio Version"), 3820 IPW2100_ORD(RADIO_VERSION, "Radio Version"),
3821 IPW2100_ORD(NIC_MANF_DATE_TIME, "MANF Date/Time STAMP"), 3821 IPW2100_ORD(NIC_MANF_DATE_TIME, "MANF Date/Time STAMP"),
3822 IPW2100_ORD(UCODE_VERSION, "Ucode Version"),}; 3822 IPW2100_ORD(UCODE_VERSION, "Ucode Version"),};
3823 3823
3824 static ssize_t show_registers(struct device *d, struct device_attribute *attr, 3824 static ssize_t show_registers(struct device *d, struct device_attribute *attr,
3825 char *buf) 3825 char *buf)
3826 { 3826 {
3827 int i; 3827 int i;
3828 struct ipw2100_priv *priv = dev_get_drvdata(d); 3828 struct ipw2100_priv *priv = dev_get_drvdata(d);
3829 struct net_device *dev = priv->net_dev; 3829 struct net_device *dev = priv->net_dev;
3830 char *out = buf; 3830 char *out = buf;
3831 u32 val = 0; 3831 u32 val = 0;
3832 3832
3833 out += sprintf(out, "%30s [Address ] : Hex\n", "Register"); 3833 out += sprintf(out, "%30s [Address ] : Hex\n", "Register");
3834 3834
3835 for (i = 0; i < ARRAY_SIZE(hw_data); i++) { 3835 for (i = 0; i < ARRAY_SIZE(hw_data); i++) {
3836 read_register(dev, hw_data[i].addr, &val); 3836 read_register(dev, hw_data[i].addr, &val);
3837 out += sprintf(out, "%30s [%08X] : %08X\n", 3837 out += sprintf(out, "%30s [%08X] : %08X\n",
3838 hw_data[i].name, hw_data[i].addr, val); 3838 hw_data[i].name, hw_data[i].addr, val);
3839 } 3839 }
3840 3840
3841 return out - buf; 3841 return out - buf;
3842 } 3842 }
3843 3843
3844 static DEVICE_ATTR(registers, S_IRUGO, show_registers, NULL); 3844 static DEVICE_ATTR(registers, S_IRUGO, show_registers, NULL);
3845 3845
3846 static ssize_t show_hardware(struct device *d, struct device_attribute *attr, 3846 static ssize_t show_hardware(struct device *d, struct device_attribute *attr,
3847 char *buf) 3847 char *buf)
3848 { 3848 {
3849 struct ipw2100_priv *priv = dev_get_drvdata(d); 3849 struct ipw2100_priv *priv = dev_get_drvdata(d);
3850 struct net_device *dev = priv->net_dev; 3850 struct net_device *dev = priv->net_dev;
3851 char *out = buf; 3851 char *out = buf;
3852 int i; 3852 int i;
3853 3853
3854 out += sprintf(out, "%30s [Address ] : Hex\n", "NIC entry"); 3854 out += sprintf(out, "%30s [Address ] : Hex\n", "NIC entry");
3855 3855
3856 for (i = 0; i < ARRAY_SIZE(nic_data); i++) { 3856 for (i = 0; i < ARRAY_SIZE(nic_data); i++) {
3857 u8 tmp8; 3857 u8 tmp8;
3858 u16 tmp16; 3858 u16 tmp16;
3859 u32 tmp32; 3859 u32 tmp32;
3860 3860
3861 switch (nic_data[i].size) { 3861 switch (nic_data[i].size) {
3862 case 1: 3862 case 1:
3863 read_nic_byte(dev, nic_data[i].addr, &tmp8); 3863 read_nic_byte(dev, nic_data[i].addr, &tmp8);
3864 out += sprintf(out, "%30s [%08X] : %02X\n", 3864 out += sprintf(out, "%30s [%08X] : %02X\n",
3865 nic_data[i].name, nic_data[i].addr, 3865 nic_data[i].name, nic_data[i].addr,
3866 tmp8); 3866 tmp8);
3867 break; 3867 break;
3868 case 2: 3868 case 2:
3869 read_nic_word(dev, nic_data[i].addr, &tmp16); 3869 read_nic_word(dev, nic_data[i].addr, &tmp16);
3870 out += sprintf(out, "%30s [%08X] : %04X\n", 3870 out += sprintf(out, "%30s [%08X] : %04X\n",
3871 nic_data[i].name, nic_data[i].addr, 3871 nic_data[i].name, nic_data[i].addr,
3872 tmp16); 3872 tmp16);
3873 break; 3873 break;
3874 case 4: 3874 case 4:
3875 read_nic_dword(dev, nic_data[i].addr, &tmp32); 3875 read_nic_dword(dev, nic_data[i].addr, &tmp32);
3876 out += sprintf(out, "%30s [%08X] : %08X\n", 3876 out += sprintf(out, "%30s [%08X] : %08X\n",
3877 nic_data[i].name, nic_data[i].addr, 3877 nic_data[i].name, nic_data[i].addr,
3878 tmp32); 3878 tmp32);
3879 break; 3879 break;
3880 } 3880 }
3881 } 3881 }
3882 return out - buf; 3882 return out - buf;
3883 } 3883 }
3884 3884
3885 static DEVICE_ATTR(hardware, S_IRUGO, show_hardware, NULL); 3885 static DEVICE_ATTR(hardware, S_IRUGO, show_hardware, NULL);
3886 3886
3887 static ssize_t show_memory(struct device *d, struct device_attribute *attr, 3887 static ssize_t show_memory(struct device *d, struct device_attribute *attr,
3888 char *buf) 3888 char *buf)
3889 { 3889 {
3890 struct ipw2100_priv *priv = dev_get_drvdata(d); 3890 struct ipw2100_priv *priv = dev_get_drvdata(d);
3891 struct net_device *dev = priv->net_dev; 3891 struct net_device *dev = priv->net_dev;
3892 static unsigned long loop = 0; 3892 static unsigned long loop = 0;
3893 int len = 0; 3893 int len = 0;
3894 u32 buffer[4]; 3894 u32 buffer[4];
3895 int i; 3895 int i;
3896 char line[81]; 3896 char line[81];
3897 3897
3898 if (loop >= 0x30000) 3898 if (loop >= 0x30000)
3899 loop = 0; 3899 loop = 0;
3900 3900
3901 /* sysfs provides us PAGE_SIZE buffer */ 3901 /* sysfs provides us PAGE_SIZE buffer */
3902 while (len < PAGE_SIZE - 128 && loop < 0x30000) { 3902 while (len < PAGE_SIZE - 128 && loop < 0x30000) {
3903 3903
3904 if (priv->snapshot[0]) 3904 if (priv->snapshot[0])
3905 for (i = 0; i < 4; i++) 3905 for (i = 0; i < 4; i++)
3906 buffer[i] = 3906 buffer[i] =
3907 *(u32 *) SNAPSHOT_ADDR(loop + i * 4); 3907 *(u32 *) SNAPSHOT_ADDR(loop + i * 4);
3908 else 3908 else
3909 for (i = 0; i < 4; i++) 3909 for (i = 0; i < 4; i++)
3910 read_nic_dword(dev, loop + i * 4, &buffer[i]); 3910 read_nic_dword(dev, loop + i * 4, &buffer[i]);
3911 3911
3912 if (priv->dump_raw) 3912 if (priv->dump_raw)
3913 len += sprintf(buf + len, 3913 len += sprintf(buf + len,
3914 "%c%c%c%c" 3914 "%c%c%c%c"
3915 "%c%c%c%c" 3915 "%c%c%c%c"
3916 "%c%c%c%c" 3916 "%c%c%c%c"
3917 "%c%c%c%c", 3917 "%c%c%c%c",
3918 ((u8 *) buffer)[0x0], 3918 ((u8 *) buffer)[0x0],
3919 ((u8 *) buffer)[0x1], 3919 ((u8 *) buffer)[0x1],
3920 ((u8 *) buffer)[0x2], 3920 ((u8 *) buffer)[0x2],
3921 ((u8 *) buffer)[0x3], 3921 ((u8 *) buffer)[0x3],
3922 ((u8 *) buffer)[0x4], 3922 ((u8 *) buffer)[0x4],
3923 ((u8 *) buffer)[0x5], 3923 ((u8 *) buffer)[0x5],
3924 ((u8 *) buffer)[0x6], 3924 ((u8 *) buffer)[0x6],
3925 ((u8 *) buffer)[0x7], 3925 ((u8 *) buffer)[0x7],
3926 ((u8 *) buffer)[0x8], 3926 ((u8 *) buffer)[0x8],
3927 ((u8 *) buffer)[0x9], 3927 ((u8 *) buffer)[0x9],
3928 ((u8 *) buffer)[0xa], 3928 ((u8 *) buffer)[0xa],
3929 ((u8 *) buffer)[0xb], 3929 ((u8 *) buffer)[0xb],
3930 ((u8 *) buffer)[0xc], 3930 ((u8 *) buffer)[0xc],
3931 ((u8 *) buffer)[0xd], 3931 ((u8 *) buffer)[0xd],
3932 ((u8 *) buffer)[0xe], 3932 ((u8 *) buffer)[0xe],
3933 ((u8 *) buffer)[0xf]); 3933 ((u8 *) buffer)[0xf]);
3934 else 3934 else
3935 len += sprintf(buf + len, "%s\n", 3935 len += sprintf(buf + len, "%s\n",
3936 snprint_line(line, sizeof(line), 3936 snprint_line(line, sizeof(line),
3937 (u8 *) buffer, 16, loop)); 3937 (u8 *) buffer, 16, loop));
3938 loop += 16; 3938 loop += 16;
3939 } 3939 }
3940 3940
3941 return len; 3941 return len;
3942 } 3942 }
3943 3943
3944 static ssize_t store_memory(struct device *d, struct device_attribute *attr, 3944 static ssize_t store_memory(struct device *d, struct device_attribute *attr,
3945 const char *buf, size_t count) 3945 const char *buf, size_t count)
3946 { 3946 {
3947 struct ipw2100_priv *priv = dev_get_drvdata(d); 3947 struct ipw2100_priv *priv = dev_get_drvdata(d);
3948 struct net_device *dev = priv->net_dev; 3948 struct net_device *dev = priv->net_dev;
3949 const char *p = buf; 3949 const char *p = buf;
3950 3950
3951 (void)dev; /* kill unused-var warning for debug-only code */ 3951 (void)dev; /* kill unused-var warning for debug-only code */
3952 3952
3953 if (count < 1) 3953 if (count < 1)
3954 return count; 3954 return count;
3955 3955
3956 if (p[0] == '1' || 3956 if (p[0] == '1' ||
3957 (count >= 2 && tolower(p[0]) == 'o' && tolower(p[1]) == 'n')) { 3957 (count >= 2 && tolower(p[0]) == 'o' && tolower(p[1]) == 'n')) {
3958 IPW_DEBUG_INFO("%s: Setting memory dump to RAW mode.\n", 3958 IPW_DEBUG_INFO("%s: Setting memory dump to RAW mode.\n",
3959 dev->name); 3959 dev->name);
3960 priv->dump_raw = 1; 3960 priv->dump_raw = 1;
3961 3961
3962 } else if (p[0] == '0' || (count >= 2 && tolower(p[0]) == 'o' && 3962 } else if (p[0] == '0' || (count >= 2 && tolower(p[0]) == 'o' &&
3963 tolower(p[1]) == 'f')) { 3963 tolower(p[1]) == 'f')) {
3964 IPW_DEBUG_INFO("%s: Setting memory dump to HEX mode.\n", 3964 IPW_DEBUG_INFO("%s: Setting memory dump to HEX mode.\n",
3965 dev->name); 3965 dev->name);
3966 priv->dump_raw = 0; 3966 priv->dump_raw = 0;
3967 3967
3968 } else if (tolower(p[0]) == 'r') { 3968 } else if (tolower(p[0]) == 'r') {
3969 IPW_DEBUG_INFO("%s: Resetting firmware snapshot.\n", dev->name); 3969 IPW_DEBUG_INFO("%s: Resetting firmware snapshot.\n", dev->name);
3970 ipw2100_snapshot_free(priv); 3970 ipw2100_snapshot_free(priv);
3971 3971
3972 } else 3972 } else
3973 IPW_DEBUG_INFO("%s: Usage: 0|on = HEX, 1|off = RAW, " 3973 IPW_DEBUG_INFO("%s: Usage: 0|on = HEX, 1|off = RAW, "
3974 "reset = clear memory snapshot\n", dev->name); 3974 "reset = clear memory snapshot\n", dev->name);
3975 3975
3976 return count; 3976 return count;
3977 } 3977 }
3978 3978
3979 static DEVICE_ATTR(memory, S_IWUSR | S_IRUGO, show_memory, store_memory); 3979 static DEVICE_ATTR(memory, S_IWUSR | S_IRUGO, show_memory, store_memory);
3980 3980
3981 static ssize_t show_ordinals(struct device *d, struct device_attribute *attr, 3981 static ssize_t show_ordinals(struct device *d, struct device_attribute *attr,
3982 char *buf) 3982 char *buf)
3983 { 3983 {
3984 struct ipw2100_priv *priv = dev_get_drvdata(d); 3984 struct ipw2100_priv *priv = dev_get_drvdata(d);
3985 u32 val = 0; 3985 u32 val = 0;
3986 int len = 0; 3986 int len = 0;
3987 u32 val_len; 3987 u32 val_len;
3988 static int loop = 0; 3988 static int loop = 0;
3989 3989
3990 if (priv->status & STATUS_RF_KILL_MASK) 3990 if (priv->status & STATUS_RF_KILL_MASK)
3991 return 0; 3991 return 0;
3992 3992
3993 if (loop >= ARRAY_SIZE(ord_data)) 3993 if (loop >= ARRAY_SIZE(ord_data))
3994 loop = 0; 3994 loop = 0;
3995 3995
3996 /* sysfs provides us PAGE_SIZE buffer */ 3996 /* sysfs provides us PAGE_SIZE buffer */
3997 while (len < PAGE_SIZE - 128 && loop < ARRAY_SIZE(ord_data)) { 3997 while (len < PAGE_SIZE - 128 && loop < ARRAY_SIZE(ord_data)) {
3998 val_len = sizeof(u32); 3998 val_len = sizeof(u32);
3999 3999
4000 if (ipw2100_get_ordinal(priv, ord_data[loop].index, &val, 4000 if (ipw2100_get_ordinal(priv, ord_data[loop].index, &val,
4001 &val_len)) 4001 &val_len))
4002 len += sprintf(buf + len, "[0x%02X] = ERROR %s\n", 4002 len += sprintf(buf + len, "[0x%02X] = ERROR %s\n",
4003 ord_data[loop].index, 4003 ord_data[loop].index,
4004 ord_data[loop].desc); 4004 ord_data[loop].desc);
4005 else 4005 else
4006 len += sprintf(buf + len, "[0x%02X] = 0x%08X %s\n", 4006 len += sprintf(buf + len, "[0x%02X] = 0x%08X %s\n",
4007 ord_data[loop].index, val, 4007 ord_data[loop].index, val,
4008 ord_data[loop].desc); 4008 ord_data[loop].desc);
4009 loop++; 4009 loop++;
4010 } 4010 }
4011 4011
4012 return len; 4012 return len;
4013 } 4013 }
4014 4014
4015 static DEVICE_ATTR(ordinals, S_IRUGO, show_ordinals, NULL); 4015 static DEVICE_ATTR(ordinals, S_IRUGO, show_ordinals, NULL);
4016 4016
4017 static ssize_t show_stats(struct device *d, struct device_attribute *attr, 4017 static ssize_t show_stats(struct device *d, struct device_attribute *attr,
4018 char *buf) 4018 char *buf)
4019 { 4019 {
4020 struct ipw2100_priv *priv = dev_get_drvdata(d); 4020 struct ipw2100_priv *priv = dev_get_drvdata(d);
4021 char *out = buf; 4021 char *out = buf;
4022 4022
4023 out += sprintf(out, "interrupts: %d {tx: %d, rx: %d, other: %d}\n", 4023 out += sprintf(out, "interrupts: %d {tx: %d, rx: %d, other: %d}\n",
4024 priv->interrupts, priv->tx_interrupts, 4024 priv->interrupts, priv->tx_interrupts,
4025 priv->rx_interrupts, priv->inta_other); 4025 priv->rx_interrupts, priv->inta_other);
4026 out += sprintf(out, "firmware resets: %d\n", priv->resets); 4026 out += sprintf(out, "firmware resets: %d\n", priv->resets);
4027 out += sprintf(out, "firmware hangs: %d\n", priv->hangs); 4027 out += sprintf(out, "firmware hangs: %d\n", priv->hangs);
4028 #ifdef CONFIG_IPW2100_DEBUG 4028 #ifdef CONFIG_IPW2100_DEBUG
4029 out += sprintf(out, "packet mismatch image: %s\n", 4029 out += sprintf(out, "packet mismatch image: %s\n",
4030 priv->snapshot[0] ? "YES" : "NO"); 4030 priv->snapshot[0] ? "YES" : "NO");
4031 #endif 4031 #endif
4032 4032
4033 return out - buf; 4033 return out - buf;
4034 } 4034 }
4035 4035
4036 static DEVICE_ATTR(stats, S_IRUGO, show_stats, NULL); 4036 static DEVICE_ATTR(stats, S_IRUGO, show_stats, NULL);
4037 4037
4038 static int ipw2100_switch_mode(struct ipw2100_priv *priv, u32 mode) 4038 static int ipw2100_switch_mode(struct ipw2100_priv *priv, u32 mode)
4039 { 4039 {
4040 int err; 4040 int err;
4041 4041
4042 if (mode == priv->ieee->iw_mode) 4042 if (mode == priv->ieee->iw_mode)
4043 return 0; 4043 return 0;
4044 4044
4045 err = ipw2100_disable_adapter(priv); 4045 err = ipw2100_disable_adapter(priv);
4046 if (err) { 4046 if (err) {
4047 printk(KERN_ERR DRV_NAME ": %s: Could not disable adapter %d\n", 4047 printk(KERN_ERR DRV_NAME ": %s: Could not disable adapter %d\n",
4048 priv->net_dev->name, err); 4048 priv->net_dev->name, err);
4049 return err; 4049 return err;
4050 } 4050 }
4051 4051
4052 switch (mode) { 4052 switch (mode) {
4053 case IW_MODE_INFRA: 4053 case IW_MODE_INFRA:
4054 priv->net_dev->type = ARPHRD_ETHER; 4054 priv->net_dev->type = ARPHRD_ETHER;
4055 break; 4055 break;
4056 case IW_MODE_ADHOC: 4056 case IW_MODE_ADHOC:
4057 priv->net_dev->type = ARPHRD_ETHER; 4057 priv->net_dev->type = ARPHRD_ETHER;
4058 break; 4058 break;
4059 #ifdef CONFIG_IPW2100_MONITOR 4059 #ifdef CONFIG_IPW2100_MONITOR
4060 case IW_MODE_MONITOR: 4060 case IW_MODE_MONITOR:
4061 priv->last_mode = priv->ieee->iw_mode; 4061 priv->last_mode = priv->ieee->iw_mode;
4062 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP; 4062 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
4063 break; 4063 break;
4064 #endif /* CONFIG_IPW2100_MONITOR */ 4064 #endif /* CONFIG_IPW2100_MONITOR */
4065 } 4065 }
4066 4066
4067 priv->ieee->iw_mode = mode; 4067 priv->ieee->iw_mode = mode;
4068 4068
4069 #ifdef CONFIG_PM 4069 #ifdef CONFIG_PM
4070 /* Indicate ipw2100_download_firmware download firmware 4070 /* Indicate ipw2100_download_firmware download firmware
4071 * from disk instead of memory. */ 4071 * from disk instead of memory. */
4072 ipw2100_firmware.version = 0; 4072 ipw2100_firmware.version = 0;
4073 #endif 4073 #endif
4074 4074
4075 printk(KERN_INFO "%s: Reseting on mode change.\n", priv->net_dev->name); 4075 printk(KERN_INFO "%s: Reseting on mode change.\n", priv->net_dev->name);
4076 priv->reset_backoff = 0; 4076 priv->reset_backoff = 0;
4077 schedule_reset(priv); 4077 schedule_reset(priv);
4078 4078
4079 return 0; 4079 return 0;
4080 } 4080 }
4081 4081
4082 static ssize_t show_internals(struct device *d, struct device_attribute *attr, 4082 static ssize_t show_internals(struct device *d, struct device_attribute *attr,
4083 char *buf) 4083 char *buf)
4084 { 4084 {
4085 struct ipw2100_priv *priv = dev_get_drvdata(d); 4085 struct ipw2100_priv *priv = dev_get_drvdata(d);
4086 int len = 0; 4086 int len = 0;
4087 4087
4088 #define DUMP_VAR(x,y) len += sprintf(buf + len, # x ": %" y "\n", priv-> x) 4088 #define DUMP_VAR(x,y) len += sprintf(buf + len, # x ": %" y "\n", priv-> x)
4089 4089
4090 if (priv->status & STATUS_ASSOCIATED) 4090 if (priv->status & STATUS_ASSOCIATED)
4091 len += sprintf(buf + len, "connected: %lu\n", 4091 len += sprintf(buf + len, "connected: %lu\n",
4092 get_seconds() - priv->connect_start); 4092 get_seconds() - priv->connect_start);
4093 else 4093 else
4094 len += sprintf(buf + len, "not connected\n"); 4094 len += sprintf(buf + len, "not connected\n");
4095 4095
4096 DUMP_VAR(ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx], "p"); 4096 DUMP_VAR(ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx], "p");
4097 DUMP_VAR(status, "08lx"); 4097 DUMP_VAR(status, "08lx");
4098 DUMP_VAR(config, "08lx"); 4098 DUMP_VAR(config, "08lx");
4099 DUMP_VAR(capability, "08lx"); 4099 DUMP_VAR(capability, "08lx");
4100 4100
4101 len += 4101 len +=
4102 sprintf(buf + len, "last_rtc: %lu\n", 4102 sprintf(buf + len, "last_rtc: %lu\n",
4103 (unsigned long)priv->last_rtc); 4103 (unsigned long)priv->last_rtc);
4104 4104
4105 DUMP_VAR(fatal_error, "d"); 4105 DUMP_VAR(fatal_error, "d");
4106 DUMP_VAR(stop_hang_check, "d"); 4106 DUMP_VAR(stop_hang_check, "d");
4107 DUMP_VAR(stop_rf_kill, "d"); 4107 DUMP_VAR(stop_rf_kill, "d");
4108 DUMP_VAR(messages_sent, "d"); 4108 DUMP_VAR(messages_sent, "d");
4109 4109
4110 DUMP_VAR(tx_pend_stat.value, "d"); 4110 DUMP_VAR(tx_pend_stat.value, "d");
4111 DUMP_VAR(tx_pend_stat.hi, "d"); 4111 DUMP_VAR(tx_pend_stat.hi, "d");
4112 4112
4113 DUMP_VAR(tx_free_stat.value, "d"); 4113 DUMP_VAR(tx_free_stat.value, "d");
4114 DUMP_VAR(tx_free_stat.lo, "d"); 4114 DUMP_VAR(tx_free_stat.lo, "d");
4115 4115
4116 DUMP_VAR(msg_free_stat.value, "d"); 4116 DUMP_VAR(msg_free_stat.value, "d");
4117 DUMP_VAR(msg_free_stat.lo, "d"); 4117 DUMP_VAR(msg_free_stat.lo, "d");
4118 4118
4119 DUMP_VAR(msg_pend_stat.value, "d"); 4119 DUMP_VAR(msg_pend_stat.value, "d");
4120 DUMP_VAR(msg_pend_stat.hi, "d"); 4120 DUMP_VAR(msg_pend_stat.hi, "d");
4121 4121
4122 DUMP_VAR(fw_pend_stat.value, "d"); 4122 DUMP_VAR(fw_pend_stat.value, "d");
4123 DUMP_VAR(fw_pend_stat.hi, "d"); 4123 DUMP_VAR(fw_pend_stat.hi, "d");
4124 4124
4125 DUMP_VAR(txq_stat.value, "d"); 4125 DUMP_VAR(txq_stat.value, "d");
4126 DUMP_VAR(txq_stat.lo, "d"); 4126 DUMP_VAR(txq_stat.lo, "d");
4127 4127
4128 DUMP_VAR(ieee->scans, "d"); 4128 DUMP_VAR(ieee->scans, "d");
4129 DUMP_VAR(reset_backoff, "d"); 4129 DUMP_VAR(reset_backoff, "d");
4130 4130
4131 return len; 4131 return len;
4132 } 4132 }
4133 4133
4134 static DEVICE_ATTR(internals, S_IRUGO, show_internals, NULL); 4134 static DEVICE_ATTR(internals, S_IRUGO, show_internals, NULL);
4135 4135
4136 static ssize_t show_bssinfo(struct device *d, struct device_attribute *attr, 4136 static ssize_t show_bssinfo(struct device *d, struct device_attribute *attr,
4137 char *buf) 4137 char *buf)
4138 { 4138 {
4139 struct ipw2100_priv *priv = dev_get_drvdata(d); 4139 struct ipw2100_priv *priv = dev_get_drvdata(d);
4140 char essid[IW_ESSID_MAX_SIZE + 1]; 4140 char essid[IW_ESSID_MAX_SIZE + 1];
4141 u8 bssid[ETH_ALEN]; 4141 u8 bssid[ETH_ALEN];
4142 u32 chan = 0; 4142 u32 chan = 0;
4143 char *out = buf; 4143 char *out = buf;
4144 unsigned int length; 4144 unsigned int length;
4145 int ret; 4145 int ret;
4146 4146
4147 if (priv->status & STATUS_RF_KILL_MASK) 4147 if (priv->status & STATUS_RF_KILL_MASK)
4148 return 0; 4148 return 0;
4149 4149
4150 memset(essid, 0, sizeof(essid)); 4150 memset(essid, 0, sizeof(essid));
4151 memset(bssid, 0, sizeof(bssid)); 4151 memset(bssid, 0, sizeof(bssid));
4152 4152
4153 length = IW_ESSID_MAX_SIZE; 4153 length = IW_ESSID_MAX_SIZE;
4154 ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_SSID, essid, &length); 4154 ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_SSID, essid, &length);
4155 if (ret) 4155 if (ret)
4156 IPW_DEBUG_INFO("failed querying ordinals at line %d\n", 4156 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
4157 __LINE__); 4157 __LINE__);
4158 4158
4159 length = sizeof(bssid); 4159 length = sizeof(bssid);
4160 ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID, 4160 ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID,
4161 bssid, &length); 4161 bssid, &length);
4162 if (ret) 4162 if (ret)
4163 IPW_DEBUG_INFO("failed querying ordinals at line %d\n", 4163 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
4164 __LINE__); 4164 __LINE__);
4165 4165
4166 length = sizeof(u32); 4166 length = sizeof(u32);
4167 ret = ipw2100_get_ordinal(priv, IPW_ORD_OUR_FREQ, &chan, &length); 4167 ret = ipw2100_get_ordinal(priv, IPW_ORD_OUR_FREQ, &chan, &length);
4168 if (ret) 4168 if (ret)
4169 IPW_DEBUG_INFO("failed querying ordinals at line %d\n", 4169 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
4170 __LINE__); 4170 __LINE__);
4171 4171
4172 out += sprintf(out, "ESSID: %s\n", essid); 4172 out += sprintf(out, "ESSID: %s\n", essid);
4173 out += sprintf(out, "BSSID: %pM\n", bssid); 4173 out += sprintf(out, "BSSID: %pM\n", bssid);
4174 out += sprintf(out, "Channel: %d\n", chan); 4174 out += sprintf(out, "Channel: %d\n", chan);
4175 4175
4176 return out - buf; 4176 return out - buf;
4177 } 4177 }
4178 4178
4179 static DEVICE_ATTR(bssinfo, S_IRUGO, show_bssinfo, NULL); 4179 static DEVICE_ATTR(bssinfo, S_IRUGO, show_bssinfo, NULL);
4180 4180
4181 #ifdef CONFIG_IPW2100_DEBUG 4181 #ifdef CONFIG_IPW2100_DEBUG
4182 static ssize_t show_debug_level(struct device_driver *d, char *buf) 4182 static ssize_t show_debug_level(struct device_driver *d, char *buf)
4183 { 4183 {
4184 return sprintf(buf, "0x%08X\n", ipw2100_debug_level); 4184 return sprintf(buf, "0x%08X\n", ipw2100_debug_level);
4185 } 4185 }
4186 4186
4187 static ssize_t store_debug_level(struct device_driver *d, 4187 static ssize_t store_debug_level(struct device_driver *d,
4188 const char *buf, size_t count) 4188 const char *buf, size_t count)
4189 { 4189 {
4190 char *p = (char *)buf; 4190 char *p = (char *)buf;
4191 u32 val; 4191 u32 val;
4192 4192
4193 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') { 4193 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
4194 p++; 4194 p++;
4195 if (p[0] == 'x' || p[0] == 'X') 4195 if (p[0] == 'x' || p[0] == 'X')
4196 p++; 4196 p++;
4197 val = simple_strtoul(p, &p, 16); 4197 val = simple_strtoul(p, &p, 16);
4198 } else 4198 } else
4199 val = simple_strtoul(p, &p, 10); 4199 val = simple_strtoul(p, &p, 10);
4200 if (p == buf) 4200 if (p == buf)
4201 IPW_DEBUG_INFO(": %s is not in hex or decimal form.\n", buf); 4201 IPW_DEBUG_INFO(": %s is not in hex or decimal form.\n", buf);
4202 else 4202 else
4203 ipw2100_debug_level = val; 4203 ipw2100_debug_level = val;
4204 4204
4205 return strnlen(buf, count); 4205 return strnlen(buf, count);
4206 } 4206 }
4207 4207
4208 static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO, show_debug_level, 4208 static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO, show_debug_level,
4209 store_debug_level); 4209 store_debug_level);
4210 #endif /* CONFIG_IPW2100_DEBUG */ 4210 #endif /* CONFIG_IPW2100_DEBUG */
4211 4211
4212 static ssize_t show_fatal_error(struct device *d, 4212 static ssize_t show_fatal_error(struct device *d,
4213 struct device_attribute *attr, char *buf) 4213 struct device_attribute *attr, char *buf)
4214 { 4214 {
4215 struct ipw2100_priv *priv = dev_get_drvdata(d); 4215 struct ipw2100_priv *priv = dev_get_drvdata(d);
4216 char *out = buf; 4216 char *out = buf;
4217 int i; 4217 int i;
4218 4218
4219 if (priv->fatal_error) 4219 if (priv->fatal_error)
4220 out += sprintf(out, "0x%08X\n", priv->fatal_error); 4220 out += sprintf(out, "0x%08X\n", priv->fatal_error);
4221 else 4221 else
4222 out += sprintf(out, "0\n"); 4222 out += sprintf(out, "0\n");
4223 4223
4224 for (i = 1; i <= IPW2100_ERROR_QUEUE; i++) { 4224 for (i = 1; i <= IPW2100_ERROR_QUEUE; i++) {
4225 if (!priv->fatal_errors[(priv->fatal_index - i) % 4225 if (!priv->fatal_errors[(priv->fatal_index - i) %
4226 IPW2100_ERROR_QUEUE]) 4226 IPW2100_ERROR_QUEUE])
4227 continue; 4227 continue;
4228 4228
4229 out += sprintf(out, "%d. 0x%08X\n", i, 4229 out += sprintf(out, "%d. 0x%08X\n", i,
4230 priv->fatal_errors[(priv->fatal_index - i) % 4230 priv->fatal_errors[(priv->fatal_index - i) %
4231 IPW2100_ERROR_QUEUE]); 4231 IPW2100_ERROR_QUEUE]);
4232 } 4232 }
4233 4233
4234 return out - buf; 4234 return out - buf;
4235 } 4235 }
4236 4236
4237 static ssize_t store_fatal_error(struct device *d, 4237 static ssize_t store_fatal_error(struct device *d,
4238 struct device_attribute *attr, const char *buf, 4238 struct device_attribute *attr, const char *buf,
4239 size_t count) 4239 size_t count)
4240 { 4240 {
4241 struct ipw2100_priv *priv = dev_get_drvdata(d); 4241 struct ipw2100_priv *priv = dev_get_drvdata(d);
4242 schedule_reset(priv); 4242 schedule_reset(priv);
4243 return count; 4243 return count;
4244 } 4244 }
4245 4245
4246 static DEVICE_ATTR(fatal_error, S_IWUSR | S_IRUGO, show_fatal_error, 4246 static DEVICE_ATTR(fatal_error, S_IWUSR | S_IRUGO, show_fatal_error,
4247 store_fatal_error); 4247 store_fatal_error);
4248 4248
4249 static ssize_t show_scan_age(struct device *d, struct device_attribute *attr, 4249 static ssize_t show_scan_age(struct device *d, struct device_attribute *attr,
4250 char *buf) 4250 char *buf)
4251 { 4251 {
4252 struct ipw2100_priv *priv = dev_get_drvdata(d); 4252 struct ipw2100_priv *priv = dev_get_drvdata(d);
4253 return sprintf(buf, "%d\n", priv->ieee->scan_age); 4253 return sprintf(buf, "%d\n", priv->ieee->scan_age);
4254 } 4254 }
4255 4255
4256 static ssize_t store_scan_age(struct device *d, struct device_attribute *attr, 4256 static ssize_t store_scan_age(struct device *d, struct device_attribute *attr,
4257 const char *buf, size_t count) 4257 const char *buf, size_t count)
4258 { 4258 {
4259 struct ipw2100_priv *priv = dev_get_drvdata(d); 4259 struct ipw2100_priv *priv = dev_get_drvdata(d);
4260 struct net_device *dev = priv->net_dev; 4260 struct net_device *dev = priv->net_dev;
4261 char buffer[] = "00000000"; 4261 char buffer[] = "00000000";
4262 unsigned long len = 4262 unsigned long len =
4263 (sizeof(buffer) - 1) > count ? count : sizeof(buffer) - 1; 4263 (sizeof(buffer) - 1) > count ? count : sizeof(buffer) - 1;
4264 unsigned long val; 4264 unsigned long val;
4265 char *p = buffer; 4265 char *p = buffer;
4266 4266
4267 (void)dev; /* kill unused-var warning for debug-only code */ 4267 (void)dev; /* kill unused-var warning for debug-only code */
4268 4268
4269 IPW_DEBUG_INFO("enter\n"); 4269 IPW_DEBUG_INFO("enter\n");
4270 4270
4271 strncpy(buffer, buf, len); 4271 strncpy(buffer, buf, len);
4272 buffer[len] = 0; 4272 buffer[len] = 0;
4273 4273
4274 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') { 4274 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
4275 p++; 4275 p++;
4276 if (p[0] == 'x' || p[0] == 'X') 4276 if (p[0] == 'x' || p[0] == 'X')
4277 p++; 4277 p++;
4278 val = simple_strtoul(p, &p, 16); 4278 val = simple_strtoul(p, &p, 16);
4279 } else 4279 } else
4280 val = simple_strtoul(p, &p, 10); 4280 val = simple_strtoul(p, &p, 10);
4281 if (p == buffer) { 4281 if (p == buffer) {
4282 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name); 4282 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
4283 } else { 4283 } else {
4284 priv->ieee->scan_age = val; 4284 priv->ieee->scan_age = val;
4285 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age); 4285 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age);
4286 } 4286 }
4287 4287
4288 IPW_DEBUG_INFO("exit\n"); 4288 IPW_DEBUG_INFO("exit\n");
4289 return len; 4289 return len;
4290 } 4290 }
4291 4291
4292 static DEVICE_ATTR(scan_age, S_IWUSR | S_IRUGO, show_scan_age, store_scan_age); 4292 static DEVICE_ATTR(scan_age, S_IWUSR | S_IRUGO, show_scan_age, store_scan_age);
4293 4293
4294 static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr, 4294 static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
4295 char *buf) 4295 char *buf)
4296 { 4296 {
4297 /* 0 - RF kill not enabled 4297 /* 0 - RF kill not enabled
4298 1 - SW based RF kill active (sysfs) 4298 1 - SW based RF kill active (sysfs)
4299 2 - HW based RF kill active 4299 2 - HW based RF kill active
4300 3 - Both HW and SW baed RF kill active */ 4300 3 - Both HW and SW baed RF kill active */
4301 struct ipw2100_priv *priv = dev_get_drvdata(d); 4301 struct ipw2100_priv *priv = dev_get_drvdata(d);
4302 int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) | 4302 int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
4303 (rf_kill_active(priv) ? 0x2 : 0x0); 4303 (rf_kill_active(priv) ? 0x2 : 0x0);
4304 return sprintf(buf, "%i\n", val); 4304 return sprintf(buf, "%i\n", val);
4305 } 4305 }
4306 4306
4307 static int ipw_radio_kill_sw(struct ipw2100_priv *priv, int disable_radio) 4307 static int ipw_radio_kill_sw(struct ipw2100_priv *priv, int disable_radio)
4308 { 4308 {
4309 if ((disable_radio ? 1 : 0) == 4309 if ((disable_radio ? 1 : 0) ==
4310 (priv->status & STATUS_RF_KILL_SW ? 1 : 0)) 4310 (priv->status & STATUS_RF_KILL_SW ? 1 : 0))
4311 return 0; 4311 return 0;
4312 4312
4313 IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n", 4313 IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n",
4314 disable_radio ? "OFF" : "ON"); 4314 disable_radio ? "OFF" : "ON");
4315 4315
4316 mutex_lock(&priv->action_mutex); 4316 mutex_lock(&priv->action_mutex);
4317 4317
4318 if (disable_radio) { 4318 if (disable_radio) {
4319 priv->status |= STATUS_RF_KILL_SW; 4319 priv->status |= STATUS_RF_KILL_SW;
4320 ipw2100_down(priv); 4320 ipw2100_down(priv);
4321 } else { 4321 } else {
4322 priv->status &= ~STATUS_RF_KILL_SW; 4322 priv->status &= ~STATUS_RF_KILL_SW;
4323 if (rf_kill_active(priv)) { 4323 if (rf_kill_active(priv)) {
4324 IPW_DEBUG_RF_KILL("Can not turn radio back on - " 4324 IPW_DEBUG_RF_KILL("Can not turn radio back on - "
4325 "disabled by HW switch\n"); 4325 "disabled by HW switch\n");
4326 /* Make sure the RF_KILL check timer is running */ 4326 /* Make sure the RF_KILL check timer is running */
4327 priv->stop_rf_kill = 0; 4327 priv->stop_rf_kill = 0;
4328 cancel_delayed_work(&priv->rf_kill); 4328 cancel_delayed_work(&priv->rf_kill);
4329 schedule_delayed_work(&priv->rf_kill, 4329 schedule_delayed_work(&priv->rf_kill,
4330 round_jiffies_relative(HZ)); 4330 round_jiffies_relative(HZ));
4331 } else 4331 } else
4332 schedule_reset(priv); 4332 schedule_reset(priv);
4333 } 4333 }
4334 4334
4335 mutex_unlock(&priv->action_mutex); 4335 mutex_unlock(&priv->action_mutex);
4336 return 1; 4336 return 1;
4337 } 4337 }
4338 4338
4339 static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr, 4339 static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
4340 const char *buf, size_t count) 4340 const char *buf, size_t count)
4341 { 4341 {
4342 struct ipw2100_priv *priv = dev_get_drvdata(d); 4342 struct ipw2100_priv *priv = dev_get_drvdata(d);
4343 ipw_radio_kill_sw(priv, buf[0] == '1'); 4343 ipw_radio_kill_sw(priv, buf[0] == '1');
4344 return count; 4344 return count;
4345 } 4345 }
4346 4346
4347 static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill); 4347 static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
4348 4348
4349 static struct attribute *ipw2100_sysfs_entries[] = { 4349 static struct attribute *ipw2100_sysfs_entries[] = {
4350 &dev_attr_hardware.attr, 4350 &dev_attr_hardware.attr,
4351 &dev_attr_registers.attr, 4351 &dev_attr_registers.attr,
4352 &dev_attr_ordinals.attr, 4352 &dev_attr_ordinals.attr,
4353 &dev_attr_pci.attr, 4353 &dev_attr_pci.attr,
4354 &dev_attr_stats.attr, 4354 &dev_attr_stats.attr,
4355 &dev_attr_internals.attr, 4355 &dev_attr_internals.attr,
4356 &dev_attr_bssinfo.attr, 4356 &dev_attr_bssinfo.attr,
4357 &dev_attr_memory.attr, 4357 &dev_attr_memory.attr,
4358 &dev_attr_scan_age.attr, 4358 &dev_attr_scan_age.attr,
4359 &dev_attr_fatal_error.attr, 4359 &dev_attr_fatal_error.attr,
4360 &dev_attr_rf_kill.attr, 4360 &dev_attr_rf_kill.attr,
4361 &dev_attr_cfg.attr, 4361 &dev_attr_cfg.attr,
4362 &dev_attr_status.attr, 4362 &dev_attr_status.attr,
4363 &dev_attr_capability.attr, 4363 &dev_attr_capability.attr,
4364 NULL, 4364 NULL,
4365 }; 4365 };
4366 4366
4367 static struct attribute_group ipw2100_attribute_group = { 4367 static struct attribute_group ipw2100_attribute_group = {
4368 .attrs = ipw2100_sysfs_entries, 4368 .attrs = ipw2100_sysfs_entries,
4369 }; 4369 };
4370 4370
4371 static int status_queue_allocate(struct ipw2100_priv *priv, int entries) 4371 static int status_queue_allocate(struct ipw2100_priv *priv, int entries)
4372 { 4372 {
4373 struct ipw2100_status_queue *q = &priv->status_queue; 4373 struct ipw2100_status_queue *q = &priv->status_queue;
4374 4374
4375 IPW_DEBUG_INFO("enter\n"); 4375 IPW_DEBUG_INFO("enter\n");
4376 4376
4377 q->size = entries * sizeof(struct ipw2100_status); 4377 q->size = entries * sizeof(struct ipw2100_status);
4378 q->drv = 4378 q->drv =
4379 (struct ipw2100_status *)pci_alloc_consistent(priv->pci_dev, 4379 (struct ipw2100_status *)pci_alloc_consistent(priv->pci_dev,
4380 q->size, &q->nic); 4380 q->size, &q->nic);
4381 if (!q->drv) { 4381 if (!q->drv) {
4382 IPW_DEBUG_WARNING("Can not allocate status queue.\n"); 4382 IPW_DEBUG_WARNING("Can not allocate status queue.\n");
4383 return -ENOMEM; 4383 return -ENOMEM;
4384 } 4384 }
4385 4385
4386 memset(q->drv, 0, q->size); 4386 memset(q->drv, 0, q->size);
4387 4387
4388 IPW_DEBUG_INFO("exit\n"); 4388 IPW_DEBUG_INFO("exit\n");
4389 4389
4390 return 0; 4390 return 0;
4391 } 4391 }
4392 4392
4393 static void status_queue_free(struct ipw2100_priv *priv) 4393 static void status_queue_free(struct ipw2100_priv *priv)
4394 { 4394 {
4395 IPW_DEBUG_INFO("enter\n"); 4395 IPW_DEBUG_INFO("enter\n");
4396 4396
4397 if (priv->status_queue.drv) { 4397 if (priv->status_queue.drv) {
4398 pci_free_consistent(priv->pci_dev, priv->status_queue.size, 4398 pci_free_consistent(priv->pci_dev, priv->status_queue.size,
4399 priv->status_queue.drv, 4399 priv->status_queue.drv,
4400 priv->status_queue.nic); 4400 priv->status_queue.nic);
4401 priv->status_queue.drv = NULL; 4401 priv->status_queue.drv = NULL;
4402 } 4402 }
4403 4403
4404 IPW_DEBUG_INFO("exit\n"); 4404 IPW_DEBUG_INFO("exit\n");
4405 } 4405 }
4406 4406
4407 static int bd_queue_allocate(struct ipw2100_priv *priv, 4407 static int bd_queue_allocate(struct ipw2100_priv *priv,
4408 struct ipw2100_bd_queue *q, int entries) 4408 struct ipw2100_bd_queue *q, int entries)
4409 { 4409 {
4410 IPW_DEBUG_INFO("enter\n"); 4410 IPW_DEBUG_INFO("enter\n");
4411 4411
4412 memset(q, 0, sizeof(struct ipw2100_bd_queue)); 4412 memset(q, 0, sizeof(struct ipw2100_bd_queue));
4413 4413
4414 q->entries = entries; 4414 q->entries = entries;
4415 q->size = entries * sizeof(struct ipw2100_bd); 4415 q->size = entries * sizeof(struct ipw2100_bd);
4416 q->drv = pci_alloc_consistent(priv->pci_dev, q->size, &q->nic); 4416 q->drv = pci_alloc_consistent(priv->pci_dev, q->size, &q->nic);
4417 if (!q->drv) { 4417 if (!q->drv) {
4418 IPW_DEBUG_INFO 4418 IPW_DEBUG_INFO
4419 ("can't allocate shared memory for buffer descriptors\n"); 4419 ("can't allocate shared memory for buffer descriptors\n");
4420 return -ENOMEM; 4420 return -ENOMEM;
4421 } 4421 }
4422 memset(q->drv, 0, q->size); 4422 memset(q->drv, 0, q->size);
4423 4423
4424 IPW_DEBUG_INFO("exit\n"); 4424 IPW_DEBUG_INFO("exit\n");
4425 4425
4426 return 0; 4426 return 0;
4427 } 4427 }
4428 4428
4429 static void bd_queue_free(struct ipw2100_priv *priv, struct ipw2100_bd_queue *q) 4429 static void bd_queue_free(struct ipw2100_priv *priv, struct ipw2100_bd_queue *q)
4430 { 4430 {
4431 IPW_DEBUG_INFO("enter\n"); 4431 IPW_DEBUG_INFO("enter\n");
4432 4432
4433 if (!q) 4433 if (!q)
4434 return; 4434 return;
4435 4435
4436 if (q->drv) { 4436 if (q->drv) {
4437 pci_free_consistent(priv->pci_dev, q->size, q->drv, q->nic); 4437 pci_free_consistent(priv->pci_dev, q->size, q->drv, q->nic);
4438 q->drv = NULL; 4438 q->drv = NULL;
4439 } 4439 }
4440 4440
4441 IPW_DEBUG_INFO("exit\n"); 4441 IPW_DEBUG_INFO("exit\n");
4442 } 4442 }
4443 4443
4444 static void bd_queue_initialize(struct ipw2100_priv *priv, 4444 static void bd_queue_initialize(struct ipw2100_priv *priv,
4445 struct ipw2100_bd_queue *q, u32 base, u32 size, 4445 struct ipw2100_bd_queue *q, u32 base, u32 size,
4446 u32 r, u32 w) 4446 u32 r, u32 w)
4447 { 4447 {
4448 IPW_DEBUG_INFO("enter\n"); 4448 IPW_DEBUG_INFO("enter\n");
4449 4449
4450 IPW_DEBUG_INFO("initializing bd queue at virt=%p, phys=%08x\n", q->drv, 4450 IPW_DEBUG_INFO("initializing bd queue at virt=%p, phys=%08x\n", q->drv,
4451 (u32) q->nic); 4451 (u32) q->nic);
4452 4452
4453 write_register(priv->net_dev, base, q->nic); 4453 write_register(priv->net_dev, base, q->nic);
4454 write_register(priv->net_dev, size, q->entries); 4454 write_register(priv->net_dev, size, q->entries);
4455 write_register(priv->net_dev, r, q->oldest); 4455 write_register(priv->net_dev, r, q->oldest);
4456 write_register(priv->net_dev, w, q->next); 4456 write_register(priv->net_dev, w, q->next);
4457 4457
4458 IPW_DEBUG_INFO("exit\n"); 4458 IPW_DEBUG_INFO("exit\n");
4459 } 4459 }
4460 4460
4461 static void ipw2100_kill_works(struct ipw2100_priv *priv) 4461 static void ipw2100_kill_works(struct ipw2100_priv *priv)
4462 { 4462 {
4463 priv->stop_rf_kill = 1; 4463 priv->stop_rf_kill = 1;
4464 priv->stop_hang_check = 1; 4464 priv->stop_hang_check = 1;
4465 cancel_delayed_work_sync(&priv->reset_work); 4465 cancel_delayed_work_sync(&priv->reset_work);
4466 cancel_delayed_work_sync(&priv->security_work); 4466 cancel_delayed_work_sync(&priv->security_work);
4467 cancel_delayed_work_sync(&priv->wx_event_work); 4467 cancel_delayed_work_sync(&priv->wx_event_work);
4468 cancel_delayed_work_sync(&priv->hang_check); 4468 cancel_delayed_work_sync(&priv->hang_check);
4469 cancel_delayed_work_sync(&priv->rf_kill); 4469 cancel_delayed_work_sync(&priv->rf_kill);
4470 cancel_work_sync(&priv->scan_event_now); 4470 cancel_work_sync(&priv->scan_event_now);
4471 cancel_delayed_work_sync(&priv->scan_event_later); 4471 cancel_delayed_work_sync(&priv->scan_event_later);
4472 } 4472 }
4473 4473
4474 static int ipw2100_tx_allocate(struct ipw2100_priv *priv) 4474 static int ipw2100_tx_allocate(struct ipw2100_priv *priv)
4475 { 4475 {
4476 int i, j, err = -EINVAL; 4476 int i, j, err = -EINVAL;
4477 void *v; 4477 void *v;
4478 dma_addr_t p; 4478 dma_addr_t p;
4479 4479
4480 IPW_DEBUG_INFO("enter\n"); 4480 IPW_DEBUG_INFO("enter\n");
4481 4481
4482 err = bd_queue_allocate(priv, &priv->tx_queue, TX_QUEUE_LENGTH); 4482 err = bd_queue_allocate(priv, &priv->tx_queue, TX_QUEUE_LENGTH);
4483 if (err) { 4483 if (err) {
4484 IPW_DEBUG_ERROR("%s: failed bd_queue_allocate\n", 4484 IPW_DEBUG_ERROR("%s: failed bd_queue_allocate\n",
4485 priv->net_dev->name); 4485 priv->net_dev->name);
4486 return err; 4486 return err;
4487 } 4487 }
4488 4488
4489 priv->tx_buffers = 4489 priv->tx_buffers =
4490 kmalloc(TX_PENDED_QUEUE_LENGTH * sizeof(struct ipw2100_tx_packet), 4490 kmalloc(TX_PENDED_QUEUE_LENGTH * sizeof(struct ipw2100_tx_packet),
4491 GFP_ATOMIC); 4491 GFP_ATOMIC);
4492 if (!priv->tx_buffers) { 4492 if (!priv->tx_buffers) {
4493 printk(KERN_ERR DRV_NAME 4493 printk(KERN_ERR DRV_NAME
4494 ": %s: alloc failed form tx buffers.\n", 4494 ": %s: alloc failed form tx buffers.\n",
4495 priv->net_dev->name); 4495 priv->net_dev->name);
4496 bd_queue_free(priv, &priv->tx_queue); 4496 bd_queue_free(priv, &priv->tx_queue);
4497 return -ENOMEM; 4497 return -ENOMEM;
4498 } 4498 }
4499 4499
4500 for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) { 4500 for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) {
4501 v = pci_alloc_consistent(priv->pci_dev, 4501 v = pci_alloc_consistent(priv->pci_dev,
4502 sizeof(struct ipw2100_data_header), 4502 sizeof(struct ipw2100_data_header),
4503 &p); 4503 &p);
4504 if (!v) { 4504 if (!v) {
4505 printk(KERN_ERR DRV_NAME 4505 printk(KERN_ERR DRV_NAME
4506 ": %s: PCI alloc failed for tx " "buffers.\n", 4506 ": %s: PCI alloc failed for tx " "buffers.\n",
4507 priv->net_dev->name); 4507 priv->net_dev->name);
4508 err = -ENOMEM; 4508 err = -ENOMEM;
4509 break; 4509 break;
4510 } 4510 }
4511 4511
4512 priv->tx_buffers[i].type = DATA; 4512 priv->tx_buffers[i].type = DATA;
4513 priv->tx_buffers[i].info.d_struct.data = 4513 priv->tx_buffers[i].info.d_struct.data =
4514 (struct ipw2100_data_header *)v; 4514 (struct ipw2100_data_header *)v;
4515 priv->tx_buffers[i].info.d_struct.data_phys = p; 4515 priv->tx_buffers[i].info.d_struct.data_phys = p;
4516 priv->tx_buffers[i].info.d_struct.txb = NULL; 4516 priv->tx_buffers[i].info.d_struct.txb = NULL;
4517 } 4517 }
4518 4518
4519 if (i == TX_PENDED_QUEUE_LENGTH) 4519 if (i == TX_PENDED_QUEUE_LENGTH)
4520 return 0; 4520 return 0;
4521 4521
4522 for (j = 0; j < i; j++) { 4522 for (j = 0; j < i; j++) {
4523 pci_free_consistent(priv->pci_dev, 4523 pci_free_consistent(priv->pci_dev,
4524 sizeof(struct ipw2100_data_header), 4524 sizeof(struct ipw2100_data_header),
4525 priv->tx_buffers[j].info.d_struct.data, 4525 priv->tx_buffers[j].info.d_struct.data,
4526 priv->tx_buffers[j].info.d_struct. 4526 priv->tx_buffers[j].info.d_struct.
4527 data_phys); 4527 data_phys);
4528 } 4528 }
4529 4529
4530 kfree(priv->tx_buffers); 4530 kfree(priv->tx_buffers);
4531 priv->tx_buffers = NULL; 4531 priv->tx_buffers = NULL;
4532 4532
4533 return err; 4533 return err;
4534 } 4534 }
4535 4535
4536 static void ipw2100_tx_initialize(struct ipw2100_priv *priv) 4536 static void ipw2100_tx_initialize(struct ipw2100_priv *priv)
4537 { 4537 {
4538 int i; 4538 int i;
4539 4539
4540 IPW_DEBUG_INFO("enter\n"); 4540 IPW_DEBUG_INFO("enter\n");
4541 4541
4542 /* 4542 /*
4543 * reinitialize packet info lists 4543 * reinitialize packet info lists
4544 */ 4544 */
4545 INIT_LIST_HEAD(&priv->fw_pend_list); 4545 INIT_LIST_HEAD(&priv->fw_pend_list);
4546 INIT_STAT(&priv->fw_pend_stat); 4546 INIT_STAT(&priv->fw_pend_stat);
4547 4547
4548 /* 4548 /*
4549 * reinitialize lists 4549 * reinitialize lists
4550 */ 4550 */
4551 INIT_LIST_HEAD(&priv->tx_pend_list); 4551 INIT_LIST_HEAD(&priv->tx_pend_list);
4552 INIT_LIST_HEAD(&priv->tx_free_list); 4552 INIT_LIST_HEAD(&priv->tx_free_list);
4553 INIT_STAT(&priv->tx_pend_stat); 4553 INIT_STAT(&priv->tx_pend_stat);
4554 INIT_STAT(&priv->tx_free_stat); 4554 INIT_STAT(&priv->tx_free_stat);
4555 4555
4556 for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) { 4556 for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) {
4557 /* We simply drop any SKBs that have been queued for 4557 /* We simply drop any SKBs that have been queued for
4558 * transmit */ 4558 * transmit */
4559 if (priv->tx_buffers[i].info.d_struct.txb) { 4559 if (priv->tx_buffers[i].info.d_struct.txb) {
4560 libipw_txb_free(priv->tx_buffers[i].info.d_struct. 4560 libipw_txb_free(priv->tx_buffers[i].info.d_struct.
4561 txb); 4561 txb);
4562 priv->tx_buffers[i].info.d_struct.txb = NULL; 4562 priv->tx_buffers[i].info.d_struct.txb = NULL;
4563 } 4563 }
4564 4564
4565 list_add_tail(&priv->tx_buffers[i].list, &priv->tx_free_list); 4565 list_add_tail(&priv->tx_buffers[i].list, &priv->tx_free_list);
4566 } 4566 }
4567 4567
4568 SET_STAT(&priv->tx_free_stat, i); 4568 SET_STAT(&priv->tx_free_stat, i);
4569 4569
4570 priv->tx_queue.oldest = 0; 4570 priv->tx_queue.oldest = 0;
4571 priv->tx_queue.available = priv->tx_queue.entries; 4571 priv->tx_queue.available = priv->tx_queue.entries;
4572 priv->tx_queue.next = 0; 4572 priv->tx_queue.next = 0;
4573 INIT_STAT(&priv->txq_stat); 4573 INIT_STAT(&priv->txq_stat);
4574 SET_STAT(&priv->txq_stat, priv->tx_queue.available); 4574 SET_STAT(&priv->txq_stat, priv->tx_queue.available);
4575 4575
4576 bd_queue_initialize(priv, &priv->tx_queue, 4576 bd_queue_initialize(priv, &priv->tx_queue,
4577 IPW_MEM_HOST_SHARED_TX_QUEUE_BD_BASE, 4577 IPW_MEM_HOST_SHARED_TX_QUEUE_BD_BASE,
4578 IPW_MEM_HOST_SHARED_TX_QUEUE_BD_SIZE, 4578 IPW_MEM_HOST_SHARED_TX_QUEUE_BD_SIZE,
4579 IPW_MEM_HOST_SHARED_TX_QUEUE_READ_INDEX, 4579 IPW_MEM_HOST_SHARED_TX_QUEUE_READ_INDEX,
4580 IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX); 4580 IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX);
4581 4581
4582 IPW_DEBUG_INFO("exit\n"); 4582 IPW_DEBUG_INFO("exit\n");
4583 4583
4584 } 4584 }
4585 4585
4586 static void ipw2100_tx_free(struct ipw2100_priv *priv) 4586 static void ipw2100_tx_free(struct ipw2100_priv *priv)
4587 { 4587 {
4588 int i; 4588 int i;
4589 4589
4590 IPW_DEBUG_INFO("enter\n"); 4590 IPW_DEBUG_INFO("enter\n");
4591 4591
4592 bd_queue_free(priv, &priv->tx_queue); 4592 bd_queue_free(priv, &priv->tx_queue);
4593 4593
4594 if (!priv->tx_buffers) 4594 if (!priv->tx_buffers)
4595 return; 4595 return;
4596 4596
4597 for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) { 4597 for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) {
4598 if (priv->tx_buffers[i].info.d_struct.txb) { 4598 if (priv->tx_buffers[i].info.d_struct.txb) {
4599 libipw_txb_free(priv->tx_buffers[i].info.d_struct. 4599 libipw_txb_free(priv->tx_buffers[i].info.d_struct.
4600 txb); 4600 txb);
4601 priv->tx_buffers[i].info.d_struct.txb = NULL; 4601 priv->tx_buffers[i].info.d_struct.txb = NULL;
4602 } 4602 }
4603 if (priv->tx_buffers[i].info.d_struct.data) 4603 if (priv->tx_buffers[i].info.d_struct.data)
4604 pci_free_consistent(priv->pci_dev, 4604 pci_free_consistent(priv->pci_dev,
4605 sizeof(struct ipw2100_data_header), 4605 sizeof(struct ipw2100_data_header),
4606 priv->tx_buffers[i].info.d_struct. 4606 priv->tx_buffers[i].info.d_struct.
4607 data, 4607 data,
4608 priv->tx_buffers[i].info.d_struct. 4608 priv->tx_buffers[i].info.d_struct.
4609 data_phys); 4609 data_phys);
4610 } 4610 }
4611 4611
4612 kfree(priv->tx_buffers); 4612 kfree(priv->tx_buffers);
4613 priv->tx_buffers = NULL; 4613 priv->tx_buffers = NULL;
4614 4614
4615 IPW_DEBUG_INFO("exit\n"); 4615 IPW_DEBUG_INFO("exit\n");
4616 } 4616 }
4617 4617
4618 static int ipw2100_rx_allocate(struct ipw2100_priv *priv) 4618 static int ipw2100_rx_allocate(struct ipw2100_priv *priv)
4619 { 4619 {
4620 int i, j, err = -EINVAL; 4620 int i, j, err = -EINVAL;
4621 4621
4622 IPW_DEBUG_INFO("enter\n"); 4622 IPW_DEBUG_INFO("enter\n");
4623 4623
4624 err = bd_queue_allocate(priv, &priv->rx_queue, RX_QUEUE_LENGTH); 4624 err = bd_queue_allocate(priv, &priv->rx_queue, RX_QUEUE_LENGTH);
4625 if (err) { 4625 if (err) {
4626 IPW_DEBUG_INFO("failed bd_queue_allocate\n"); 4626 IPW_DEBUG_INFO("failed bd_queue_allocate\n");
4627 return err; 4627 return err;
4628 } 4628 }
4629 4629
4630 err = status_queue_allocate(priv, RX_QUEUE_LENGTH); 4630 err = status_queue_allocate(priv, RX_QUEUE_LENGTH);
4631 if (err) { 4631 if (err) {
4632 IPW_DEBUG_INFO("failed status_queue_allocate\n"); 4632 IPW_DEBUG_INFO("failed status_queue_allocate\n");
4633 bd_queue_free(priv, &priv->rx_queue); 4633 bd_queue_free(priv, &priv->rx_queue);
4634 return err; 4634 return err;
4635 } 4635 }
4636 4636
4637 /* 4637 /*
4638 * allocate packets 4638 * allocate packets
4639 */ 4639 */
4640 priv->rx_buffers = kmalloc(RX_QUEUE_LENGTH * 4640 priv->rx_buffers = kmalloc(RX_QUEUE_LENGTH *
4641 sizeof(struct ipw2100_rx_packet), 4641 sizeof(struct ipw2100_rx_packet),
4642 GFP_KERNEL); 4642 GFP_KERNEL);
4643 if (!priv->rx_buffers) { 4643 if (!priv->rx_buffers) {
4644 IPW_DEBUG_INFO("can't allocate rx packet buffer table\n"); 4644 IPW_DEBUG_INFO("can't allocate rx packet buffer table\n");
4645 4645
4646 bd_queue_free(priv, &priv->rx_queue); 4646 bd_queue_free(priv, &priv->rx_queue);
4647 4647
4648 status_queue_free(priv); 4648 status_queue_free(priv);
4649 4649
4650 return -ENOMEM; 4650 return -ENOMEM;
4651 } 4651 }
4652 4652
4653 for (i = 0; i < RX_QUEUE_LENGTH; i++) { 4653 for (i = 0; i < RX_QUEUE_LENGTH; i++) {
4654 struct ipw2100_rx_packet *packet = &priv->rx_buffers[i]; 4654 struct ipw2100_rx_packet *packet = &priv->rx_buffers[i];
4655 4655
4656 err = ipw2100_alloc_skb(priv, packet); 4656 err = ipw2100_alloc_skb(priv, packet);
4657 if (unlikely(err)) { 4657 if (unlikely(err)) {
4658 err = -ENOMEM; 4658 err = -ENOMEM;
4659 break; 4659 break;
4660 } 4660 }
4661 4661
4662 /* The BD holds the cache aligned address */ 4662 /* The BD holds the cache aligned address */
4663 priv->rx_queue.drv[i].host_addr = packet->dma_addr; 4663 priv->rx_queue.drv[i].host_addr = packet->dma_addr;
4664 priv->rx_queue.drv[i].buf_length = IPW_RX_NIC_BUFFER_LENGTH; 4664 priv->rx_queue.drv[i].buf_length = IPW_RX_NIC_BUFFER_LENGTH;
4665 priv->status_queue.drv[i].status_fields = 0; 4665 priv->status_queue.drv[i].status_fields = 0;
4666 } 4666 }
4667 4667
4668 if (i == RX_QUEUE_LENGTH) 4668 if (i == RX_QUEUE_LENGTH)
4669 return 0; 4669 return 0;
4670 4670
4671 for (j = 0; j < i; j++) { 4671 for (j = 0; j < i; j++) {
4672 pci_unmap_single(priv->pci_dev, priv->rx_buffers[j].dma_addr, 4672 pci_unmap_single(priv->pci_dev, priv->rx_buffers[j].dma_addr,
4673 sizeof(struct ipw2100_rx_packet), 4673 sizeof(struct ipw2100_rx_packet),
4674 PCI_DMA_FROMDEVICE); 4674 PCI_DMA_FROMDEVICE);
4675 dev_kfree_skb(priv->rx_buffers[j].skb); 4675 dev_kfree_skb(priv->rx_buffers[j].skb);
4676 } 4676 }
4677 4677
4678 kfree(priv->rx_buffers); 4678 kfree(priv->rx_buffers);
4679 priv->rx_buffers = NULL; 4679 priv->rx_buffers = NULL;
4680 4680
4681 bd_queue_free(priv, &priv->rx_queue); 4681 bd_queue_free(priv, &priv->rx_queue);
4682 4682
4683 status_queue_free(priv); 4683 status_queue_free(priv);
4684 4684
4685 return err; 4685 return err;
4686 } 4686 }
4687 4687
4688 static void ipw2100_rx_initialize(struct ipw2100_priv *priv) 4688 static void ipw2100_rx_initialize(struct ipw2100_priv *priv)
4689 { 4689 {
4690 IPW_DEBUG_INFO("enter\n"); 4690 IPW_DEBUG_INFO("enter\n");
4691 4691
4692 priv->rx_queue.oldest = 0; 4692 priv->rx_queue.oldest = 0;
4693 priv->rx_queue.available = priv->rx_queue.entries - 1; 4693 priv->rx_queue.available = priv->rx_queue.entries - 1;
4694 priv->rx_queue.next = priv->rx_queue.entries - 1; 4694 priv->rx_queue.next = priv->rx_queue.entries - 1;
4695 4695
4696 INIT_STAT(&priv->rxq_stat); 4696 INIT_STAT(&priv->rxq_stat);
4697 SET_STAT(&priv->rxq_stat, priv->rx_queue.available); 4697 SET_STAT(&priv->rxq_stat, priv->rx_queue.available);
4698 4698
4699 bd_queue_initialize(priv, &priv->rx_queue, 4699 bd_queue_initialize(priv, &priv->rx_queue,
4700 IPW_MEM_HOST_SHARED_RX_BD_BASE, 4700 IPW_MEM_HOST_SHARED_RX_BD_BASE,
4701 IPW_MEM_HOST_SHARED_RX_BD_SIZE, 4701 IPW_MEM_HOST_SHARED_RX_BD_SIZE,
4702 IPW_MEM_HOST_SHARED_RX_READ_INDEX, 4702 IPW_MEM_HOST_SHARED_RX_READ_INDEX,
4703 IPW_MEM_HOST_SHARED_RX_WRITE_INDEX); 4703 IPW_MEM_HOST_SHARED_RX_WRITE_INDEX);
4704 4704
4705 /* set up the status queue */ 4705 /* set up the status queue */
4706 write_register(priv->net_dev, IPW_MEM_HOST_SHARED_RX_STATUS_BASE, 4706 write_register(priv->net_dev, IPW_MEM_HOST_SHARED_RX_STATUS_BASE,
4707 priv->status_queue.nic); 4707 priv->status_queue.nic);
4708 4708
4709 IPW_DEBUG_INFO("exit\n"); 4709 IPW_DEBUG_INFO("exit\n");
4710 } 4710 }
4711 4711
4712 static void ipw2100_rx_free(struct ipw2100_priv *priv) 4712 static void ipw2100_rx_free(struct ipw2100_priv *priv)
4713 { 4713 {
4714 int i; 4714 int i;
4715 4715
4716 IPW_DEBUG_INFO("enter\n"); 4716 IPW_DEBUG_INFO("enter\n");
4717 4717
4718 bd_queue_free(priv, &priv->rx_queue); 4718 bd_queue_free(priv, &priv->rx_queue);
4719 status_queue_free(priv); 4719 status_queue_free(priv);
4720 4720
4721 if (!priv->rx_buffers) 4721 if (!priv->rx_buffers)
4722 return; 4722 return;
4723 4723
4724 for (i = 0; i < RX_QUEUE_LENGTH; i++) { 4724 for (i = 0; i < RX_QUEUE_LENGTH; i++) {
4725 if (priv->rx_buffers[i].rxp) { 4725 if (priv->rx_buffers[i].rxp) {
4726 pci_unmap_single(priv->pci_dev, 4726 pci_unmap_single(priv->pci_dev,
4727 priv->rx_buffers[i].dma_addr, 4727 priv->rx_buffers[i].dma_addr,
4728 sizeof(struct ipw2100_rx), 4728 sizeof(struct ipw2100_rx),
4729 PCI_DMA_FROMDEVICE); 4729 PCI_DMA_FROMDEVICE);
4730 dev_kfree_skb(priv->rx_buffers[i].skb); 4730 dev_kfree_skb(priv->rx_buffers[i].skb);
4731 } 4731 }
4732 } 4732 }
4733 4733
4734 kfree(priv->rx_buffers); 4734 kfree(priv->rx_buffers);
4735 priv->rx_buffers = NULL; 4735 priv->rx_buffers = NULL;
4736 4736
4737 IPW_DEBUG_INFO("exit\n"); 4737 IPW_DEBUG_INFO("exit\n");
4738 } 4738 }
4739 4739
4740 static int ipw2100_read_mac_address(struct ipw2100_priv *priv) 4740 static int ipw2100_read_mac_address(struct ipw2100_priv *priv)
4741 { 4741 {
4742 u32 length = ETH_ALEN; 4742 u32 length = ETH_ALEN;
4743 u8 addr[ETH_ALEN]; 4743 u8 addr[ETH_ALEN];
4744 4744
4745 int err; 4745 int err;
4746 4746
4747 err = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ADAPTER_MAC, addr, &length); 4747 err = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ADAPTER_MAC, addr, &length);
4748 if (err) { 4748 if (err) {
4749 IPW_DEBUG_INFO("MAC address read failed\n"); 4749 IPW_DEBUG_INFO("MAC address read failed\n");
4750 return -EIO; 4750 return -EIO;
4751 } 4751 }
4752 4752
4753 memcpy(priv->net_dev->dev_addr, addr, ETH_ALEN); 4753 memcpy(priv->net_dev->dev_addr, addr, ETH_ALEN);
4754 IPW_DEBUG_INFO("card MAC is %pM\n", priv->net_dev->dev_addr); 4754 IPW_DEBUG_INFO("card MAC is %pM\n", priv->net_dev->dev_addr);
4755 4755
4756 return 0; 4756 return 0;
4757 } 4757 }
4758 4758
4759 /******************************************************************** 4759 /********************************************************************
4760 * 4760 *
4761 * Firmware Commands 4761 * Firmware Commands
4762 * 4762 *
4763 ********************************************************************/ 4763 ********************************************************************/
4764 4764
4765 static int ipw2100_set_mac_address(struct ipw2100_priv *priv, int batch_mode) 4765 static int ipw2100_set_mac_address(struct ipw2100_priv *priv, int batch_mode)
4766 { 4766 {
4767 struct host_command cmd = { 4767 struct host_command cmd = {
4768 .host_command = ADAPTER_ADDRESS, 4768 .host_command = ADAPTER_ADDRESS,
4769 .host_command_sequence = 0, 4769 .host_command_sequence = 0,
4770 .host_command_length = ETH_ALEN 4770 .host_command_length = ETH_ALEN
4771 }; 4771 };
4772 int err; 4772 int err;
4773 4773
4774 IPW_DEBUG_HC("SET_MAC_ADDRESS\n"); 4774 IPW_DEBUG_HC("SET_MAC_ADDRESS\n");
4775 4775
4776 IPW_DEBUG_INFO("enter\n"); 4776 IPW_DEBUG_INFO("enter\n");
4777 4777
4778 if (priv->config & CFG_CUSTOM_MAC) { 4778 if (priv->config & CFG_CUSTOM_MAC) {
4779 memcpy(cmd.host_command_parameters, priv->mac_addr, ETH_ALEN); 4779 memcpy(cmd.host_command_parameters, priv->mac_addr, ETH_ALEN);
4780 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN); 4780 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
4781 } else 4781 } else
4782 memcpy(cmd.host_command_parameters, priv->net_dev->dev_addr, 4782 memcpy(cmd.host_command_parameters, priv->net_dev->dev_addr,
4783 ETH_ALEN); 4783 ETH_ALEN);
4784 4784
4785 err = ipw2100_hw_send_command(priv, &cmd); 4785 err = ipw2100_hw_send_command(priv, &cmd);
4786 4786
4787 IPW_DEBUG_INFO("exit\n"); 4787 IPW_DEBUG_INFO("exit\n");
4788 return err; 4788 return err;
4789 } 4789 }
4790 4790
4791 static int ipw2100_set_port_type(struct ipw2100_priv *priv, u32 port_type, 4791 static int ipw2100_set_port_type(struct ipw2100_priv *priv, u32 port_type,
4792 int batch_mode) 4792 int batch_mode)
4793 { 4793 {
4794 struct host_command cmd = { 4794 struct host_command cmd = {
4795 .host_command = PORT_TYPE, 4795 .host_command = PORT_TYPE,
4796 .host_command_sequence = 0, 4796 .host_command_sequence = 0,
4797 .host_command_length = sizeof(u32) 4797 .host_command_length = sizeof(u32)
4798 }; 4798 };
4799 int err; 4799 int err;
4800 4800
4801 switch (port_type) { 4801 switch (port_type) {
4802 case IW_MODE_INFRA: 4802 case IW_MODE_INFRA:
4803 cmd.host_command_parameters[0] = IPW_BSS; 4803 cmd.host_command_parameters[0] = IPW_BSS;
4804 break; 4804 break;
4805 case IW_MODE_ADHOC: 4805 case IW_MODE_ADHOC:
4806 cmd.host_command_parameters[0] = IPW_IBSS; 4806 cmd.host_command_parameters[0] = IPW_IBSS;
4807 break; 4807 break;
4808 } 4808 }
4809 4809
4810 IPW_DEBUG_HC("PORT_TYPE: %s\n", 4810 IPW_DEBUG_HC("PORT_TYPE: %s\n",
4811 port_type == IPW_IBSS ? "Ad-Hoc" : "Managed"); 4811 port_type == IPW_IBSS ? "Ad-Hoc" : "Managed");
4812 4812
4813 if (!batch_mode) { 4813 if (!batch_mode) {
4814 err = ipw2100_disable_adapter(priv); 4814 err = ipw2100_disable_adapter(priv);
4815 if (err) { 4815 if (err) {
4816 printk(KERN_ERR DRV_NAME 4816 printk(KERN_ERR DRV_NAME
4817 ": %s: Could not disable adapter %d\n", 4817 ": %s: Could not disable adapter %d\n",
4818 priv->net_dev->name, err); 4818 priv->net_dev->name, err);
4819 return err; 4819 return err;
4820 } 4820 }
4821 } 4821 }
4822 4822
4823 /* send cmd to firmware */ 4823 /* send cmd to firmware */
4824 err = ipw2100_hw_send_command(priv, &cmd); 4824 err = ipw2100_hw_send_command(priv, &cmd);
4825 4825
4826 if (!batch_mode) 4826 if (!batch_mode)
4827 ipw2100_enable_adapter(priv); 4827 ipw2100_enable_adapter(priv);
4828 4828
4829 return err; 4829 return err;
4830 } 4830 }
4831 4831
4832 static int ipw2100_set_channel(struct ipw2100_priv *priv, u32 channel, 4832 static int ipw2100_set_channel(struct ipw2100_priv *priv, u32 channel,
4833 int batch_mode) 4833 int batch_mode)
4834 { 4834 {
4835 struct host_command cmd = { 4835 struct host_command cmd = {
4836 .host_command = CHANNEL, 4836 .host_command = CHANNEL,
4837 .host_command_sequence = 0, 4837 .host_command_sequence = 0,
4838 .host_command_length = sizeof(u32) 4838 .host_command_length = sizeof(u32)
4839 }; 4839 };
4840 int err; 4840 int err;
4841 4841
4842 cmd.host_command_parameters[0] = channel; 4842 cmd.host_command_parameters[0] = channel;
4843 4843
4844 IPW_DEBUG_HC("CHANNEL: %d\n", channel); 4844 IPW_DEBUG_HC("CHANNEL: %d\n", channel);
4845 4845
4846 /* If BSS then we don't support channel selection */ 4846 /* If BSS then we don't support channel selection */
4847 if (priv->ieee->iw_mode == IW_MODE_INFRA) 4847 if (priv->ieee->iw_mode == IW_MODE_INFRA)
4848 return 0; 4848 return 0;
4849 4849
4850 if ((channel != 0) && 4850 if ((channel != 0) &&
4851 ((channel < REG_MIN_CHANNEL) || (channel > REG_MAX_CHANNEL))) 4851 ((channel < REG_MIN_CHANNEL) || (channel > REG_MAX_CHANNEL)))
4852 return -EINVAL; 4852 return -EINVAL;
4853 4853
4854 if (!batch_mode) { 4854 if (!batch_mode) {
4855 err = ipw2100_disable_adapter(priv); 4855 err = ipw2100_disable_adapter(priv);
4856 if (err) 4856 if (err)
4857 return err; 4857 return err;
4858 } 4858 }
4859 4859
4860 err = ipw2100_hw_send_command(priv, &cmd); 4860 err = ipw2100_hw_send_command(priv, &cmd);
4861 if (err) { 4861 if (err) {
4862 IPW_DEBUG_INFO("Failed to set channel to %d", channel); 4862 IPW_DEBUG_INFO("Failed to set channel to %d", channel);
4863 return err; 4863 return err;
4864 } 4864 }
4865 4865
4866 if (channel) 4866 if (channel)
4867 priv->config |= CFG_STATIC_CHANNEL; 4867 priv->config |= CFG_STATIC_CHANNEL;
4868 else 4868 else
4869 priv->config &= ~CFG_STATIC_CHANNEL; 4869 priv->config &= ~CFG_STATIC_CHANNEL;
4870 4870
4871 priv->channel = channel; 4871 priv->channel = channel;
4872 4872
4873 if (!batch_mode) { 4873 if (!batch_mode) {
4874 err = ipw2100_enable_adapter(priv); 4874 err = ipw2100_enable_adapter(priv);
4875 if (err) 4875 if (err)
4876 return err; 4876 return err;
4877 } 4877 }
4878 4878
4879 return 0; 4879 return 0;
4880 } 4880 }
4881 4881
4882 static int ipw2100_system_config(struct ipw2100_priv *priv, int batch_mode) 4882 static int ipw2100_system_config(struct ipw2100_priv *priv, int batch_mode)
4883 { 4883 {
4884 struct host_command cmd = { 4884 struct host_command cmd = {
4885 .host_command = SYSTEM_CONFIG, 4885 .host_command = SYSTEM_CONFIG,
4886 .host_command_sequence = 0, 4886 .host_command_sequence = 0,
4887 .host_command_length = 12, 4887 .host_command_length = 12,
4888 }; 4888 };
4889 u32 ibss_mask, len = sizeof(u32); 4889 u32 ibss_mask, len = sizeof(u32);
4890 int err; 4890 int err;
4891 4891
4892 /* Set system configuration */ 4892 /* Set system configuration */
4893 4893
4894 if (!batch_mode) { 4894 if (!batch_mode) {
4895 err = ipw2100_disable_adapter(priv); 4895 err = ipw2100_disable_adapter(priv);
4896 if (err) 4896 if (err)
4897 return err; 4897 return err;
4898 } 4898 }
4899 4899
4900 if (priv->ieee->iw_mode == IW_MODE_ADHOC) 4900 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
4901 cmd.host_command_parameters[0] |= IPW_CFG_IBSS_AUTO_START; 4901 cmd.host_command_parameters[0] |= IPW_CFG_IBSS_AUTO_START;
4902 4902
4903 cmd.host_command_parameters[0] |= IPW_CFG_IBSS_MASK | 4903 cmd.host_command_parameters[0] |= IPW_CFG_IBSS_MASK |
4904 IPW_CFG_BSS_MASK | IPW_CFG_802_1x_ENABLE; 4904 IPW_CFG_BSS_MASK | IPW_CFG_802_1x_ENABLE;
4905 4905
4906 if (!(priv->config & CFG_LONG_PREAMBLE)) 4906 if (!(priv->config & CFG_LONG_PREAMBLE))
4907 cmd.host_command_parameters[0] |= IPW_CFG_PREAMBLE_AUTO; 4907 cmd.host_command_parameters[0] |= IPW_CFG_PREAMBLE_AUTO;
4908 4908
4909 err = ipw2100_get_ordinal(priv, 4909 err = ipw2100_get_ordinal(priv,
4910 IPW_ORD_EEPROM_IBSS_11B_CHANNELS, 4910 IPW_ORD_EEPROM_IBSS_11B_CHANNELS,
4911 &ibss_mask, &len); 4911 &ibss_mask, &len);
4912 if (err) 4912 if (err)
4913 ibss_mask = IPW_IBSS_11B_DEFAULT_MASK; 4913 ibss_mask = IPW_IBSS_11B_DEFAULT_MASK;
4914 4914
4915 cmd.host_command_parameters[1] = REG_CHANNEL_MASK; 4915 cmd.host_command_parameters[1] = REG_CHANNEL_MASK;
4916 cmd.host_command_parameters[2] = REG_CHANNEL_MASK & ibss_mask; 4916 cmd.host_command_parameters[2] = REG_CHANNEL_MASK & ibss_mask;
4917 4917
4918 /* 11b only */ 4918 /* 11b only */
4919 /*cmd.host_command_parameters[0] |= DIVERSITY_ANTENNA_A; */ 4919 /*cmd.host_command_parameters[0] |= DIVERSITY_ANTENNA_A; */
4920 4920
4921 err = ipw2100_hw_send_command(priv, &cmd); 4921 err = ipw2100_hw_send_command(priv, &cmd);
4922 if (err) 4922 if (err)
4923 return err; 4923 return err;
4924 4924
4925 /* If IPv6 is configured in the kernel then we don't want to filter out all 4925 /* If IPv6 is configured in the kernel then we don't want to filter out all
4926 * of the multicast packets as IPv6 needs some. */ 4926 * of the multicast packets as IPv6 needs some. */
4927 #if !defined(CONFIG_IPV6) && !defined(CONFIG_IPV6_MODULE) 4927 #if !defined(CONFIG_IPV6) && !defined(CONFIG_IPV6_MODULE)
4928 cmd.host_command = ADD_MULTICAST; 4928 cmd.host_command = ADD_MULTICAST;
4929 cmd.host_command_sequence = 0; 4929 cmd.host_command_sequence = 0;
4930 cmd.host_command_length = 0; 4930 cmd.host_command_length = 0;
4931 4931
4932 ipw2100_hw_send_command(priv, &cmd); 4932 ipw2100_hw_send_command(priv, &cmd);
4933 #endif 4933 #endif
4934 if (!batch_mode) { 4934 if (!batch_mode) {
4935 err = ipw2100_enable_adapter(priv); 4935 err = ipw2100_enable_adapter(priv);
4936 if (err) 4936 if (err)
4937 return err; 4937 return err;
4938 } 4938 }
4939 4939
4940 return 0; 4940 return 0;
4941 } 4941 }
4942 4942
4943 static int ipw2100_set_tx_rates(struct ipw2100_priv *priv, u32 rate, 4943 static int ipw2100_set_tx_rates(struct ipw2100_priv *priv, u32 rate,
4944 int batch_mode) 4944 int batch_mode)
4945 { 4945 {
4946 struct host_command cmd = { 4946 struct host_command cmd = {
4947 .host_command = BASIC_TX_RATES, 4947 .host_command = BASIC_TX_RATES,
4948 .host_command_sequence = 0, 4948 .host_command_sequence = 0,
4949 .host_command_length = 4 4949 .host_command_length = 4
4950 }; 4950 };
4951 int err; 4951 int err;
4952 4952
4953 cmd.host_command_parameters[0] = rate & TX_RATE_MASK; 4953 cmd.host_command_parameters[0] = rate & TX_RATE_MASK;
4954 4954
4955 if (!batch_mode) { 4955 if (!batch_mode) {
4956 err = ipw2100_disable_adapter(priv); 4956 err = ipw2100_disable_adapter(priv);
4957 if (err) 4957 if (err)
4958 return err; 4958 return err;
4959 } 4959 }
4960 4960
4961 /* Set BASIC TX Rate first */ 4961 /* Set BASIC TX Rate first */
4962 ipw2100_hw_send_command(priv, &cmd); 4962 ipw2100_hw_send_command(priv, &cmd);
4963 4963
4964 /* Set TX Rate */ 4964 /* Set TX Rate */
4965 cmd.host_command = TX_RATES; 4965 cmd.host_command = TX_RATES;
4966 ipw2100_hw_send_command(priv, &cmd); 4966 ipw2100_hw_send_command(priv, &cmd);
4967 4967
4968 /* Set MSDU TX Rate */ 4968 /* Set MSDU TX Rate */
4969 cmd.host_command = MSDU_TX_RATES; 4969 cmd.host_command = MSDU_TX_RATES;
4970 ipw2100_hw_send_command(priv, &cmd); 4970 ipw2100_hw_send_command(priv, &cmd);
4971 4971
4972 if (!batch_mode) { 4972 if (!batch_mode) {
4973 err = ipw2100_enable_adapter(priv); 4973 err = ipw2100_enable_adapter(priv);
4974 if (err) 4974 if (err)
4975 return err; 4975 return err;
4976 } 4976 }
4977 4977
4978 priv->tx_rates = rate; 4978 priv->tx_rates = rate;
4979 4979
4980 return 0; 4980 return 0;
4981 } 4981 }
4982 4982
4983 static int ipw2100_set_power_mode(struct ipw2100_priv *priv, int power_level) 4983 static int ipw2100_set_power_mode(struct ipw2100_priv *priv, int power_level)
4984 { 4984 {
4985 struct host_command cmd = { 4985 struct host_command cmd = {
4986 .host_command = POWER_MODE, 4986 .host_command = POWER_MODE,
4987 .host_command_sequence = 0, 4987 .host_command_sequence = 0,
4988 .host_command_length = 4 4988 .host_command_length = 4
4989 }; 4989 };
4990 int err; 4990 int err;
4991 4991
4992 cmd.host_command_parameters[0] = power_level; 4992 cmd.host_command_parameters[0] = power_level;
4993 4993
4994 err = ipw2100_hw_send_command(priv, &cmd); 4994 err = ipw2100_hw_send_command(priv, &cmd);
4995 if (err) 4995 if (err)
4996 return err; 4996 return err;
4997 4997
4998 if (power_level == IPW_POWER_MODE_CAM) 4998 if (power_level == IPW_POWER_MODE_CAM)
4999 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode); 4999 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
5000 else 5000 else
5001 priv->power_mode = IPW_POWER_ENABLED | power_level; 5001 priv->power_mode = IPW_POWER_ENABLED | power_level;
5002 5002
5003 #ifdef IPW2100_TX_POWER 5003 #ifdef IPW2100_TX_POWER
5004 if (priv->port_type == IBSS && priv->adhoc_power != DFTL_IBSS_TX_POWER) { 5004 if (priv->port_type == IBSS && priv->adhoc_power != DFTL_IBSS_TX_POWER) {
5005 /* Set beacon interval */ 5005 /* Set beacon interval */
5006 cmd.host_command = TX_POWER_INDEX; 5006 cmd.host_command = TX_POWER_INDEX;
5007 cmd.host_command_parameters[0] = (u32) priv->adhoc_power; 5007 cmd.host_command_parameters[0] = (u32) priv->adhoc_power;
5008 5008
5009 err = ipw2100_hw_send_command(priv, &cmd); 5009 err = ipw2100_hw_send_command(priv, &cmd);
5010 if (err) 5010 if (err)
5011 return err; 5011 return err;
5012 } 5012 }
5013 #endif 5013 #endif
5014 5014
5015 return 0; 5015 return 0;
5016 } 5016 }
5017 5017
5018 static int ipw2100_set_rts_threshold(struct ipw2100_priv *priv, u32 threshold) 5018 static int ipw2100_set_rts_threshold(struct ipw2100_priv *priv, u32 threshold)
5019 { 5019 {
5020 struct host_command cmd = { 5020 struct host_command cmd = {
5021 .host_command = RTS_THRESHOLD, 5021 .host_command = RTS_THRESHOLD,
5022 .host_command_sequence = 0, 5022 .host_command_sequence = 0,
5023 .host_command_length = 4 5023 .host_command_length = 4
5024 }; 5024 };
5025 int err; 5025 int err;
5026 5026
5027 if (threshold & RTS_DISABLED) 5027 if (threshold & RTS_DISABLED)
5028 cmd.host_command_parameters[0] = MAX_RTS_THRESHOLD; 5028 cmd.host_command_parameters[0] = MAX_RTS_THRESHOLD;
5029 else 5029 else
5030 cmd.host_command_parameters[0] = threshold & ~RTS_DISABLED; 5030 cmd.host_command_parameters[0] = threshold & ~RTS_DISABLED;
5031 5031
5032 err = ipw2100_hw_send_command(priv, &cmd); 5032 err = ipw2100_hw_send_command(priv, &cmd);
5033 if (err) 5033 if (err)
5034 return err; 5034 return err;
5035 5035
5036 priv->rts_threshold = threshold; 5036 priv->rts_threshold = threshold;
5037 5037
5038 return 0; 5038 return 0;
5039 } 5039 }
5040 5040
5041 #if 0 5041 #if 0
5042 int ipw2100_set_fragmentation_threshold(struct ipw2100_priv *priv, 5042 int ipw2100_set_fragmentation_threshold(struct ipw2100_priv *priv,
5043 u32 threshold, int batch_mode) 5043 u32 threshold, int batch_mode)
5044 { 5044 {
5045 struct host_command cmd = { 5045 struct host_command cmd = {
5046 .host_command = FRAG_THRESHOLD, 5046 .host_command = FRAG_THRESHOLD,
5047 .host_command_sequence = 0, 5047 .host_command_sequence = 0,
5048 .host_command_length = 4, 5048 .host_command_length = 4,
5049 .host_command_parameters[0] = 0, 5049 .host_command_parameters[0] = 0,
5050 }; 5050 };
5051 int err; 5051 int err;
5052 5052
5053 if (!batch_mode) { 5053 if (!batch_mode) {
5054 err = ipw2100_disable_adapter(priv); 5054 err = ipw2100_disable_adapter(priv);
5055 if (err) 5055 if (err)
5056 return err; 5056 return err;
5057 } 5057 }
5058 5058
5059 if (threshold == 0) 5059 if (threshold == 0)
5060 threshold = DEFAULT_FRAG_THRESHOLD; 5060 threshold = DEFAULT_FRAG_THRESHOLD;
5061 else { 5061 else {
5062 threshold = max(threshold, MIN_FRAG_THRESHOLD); 5062 threshold = max(threshold, MIN_FRAG_THRESHOLD);
5063 threshold = min(threshold, MAX_FRAG_THRESHOLD); 5063 threshold = min(threshold, MAX_FRAG_THRESHOLD);
5064 } 5064 }
5065 5065
5066 cmd.host_command_parameters[0] = threshold; 5066 cmd.host_command_parameters[0] = threshold;
5067 5067
5068 IPW_DEBUG_HC("FRAG_THRESHOLD: %u\n", threshold); 5068 IPW_DEBUG_HC("FRAG_THRESHOLD: %u\n", threshold);
5069 5069
5070 err = ipw2100_hw_send_command(priv, &cmd); 5070 err = ipw2100_hw_send_command(priv, &cmd);
5071 5071
5072 if (!batch_mode) 5072 if (!batch_mode)
5073 ipw2100_enable_adapter(priv); 5073 ipw2100_enable_adapter(priv);
5074 5074
5075 if (!err) 5075 if (!err)
5076 priv->frag_threshold = threshold; 5076 priv->frag_threshold = threshold;
5077 5077
5078 return err; 5078 return err;
5079 } 5079 }
5080 #endif 5080 #endif
5081 5081
5082 static int ipw2100_set_short_retry(struct ipw2100_priv *priv, u32 retry) 5082 static int ipw2100_set_short_retry(struct ipw2100_priv *priv, u32 retry)
5083 { 5083 {
5084 struct host_command cmd = { 5084 struct host_command cmd = {
5085 .host_command = SHORT_RETRY_LIMIT, 5085 .host_command = SHORT_RETRY_LIMIT,
5086 .host_command_sequence = 0, 5086 .host_command_sequence = 0,
5087 .host_command_length = 4 5087 .host_command_length = 4
5088 }; 5088 };
5089 int err; 5089 int err;
5090 5090
5091 cmd.host_command_parameters[0] = retry; 5091 cmd.host_command_parameters[0] = retry;
5092 5092
5093 err = ipw2100_hw_send_command(priv, &cmd); 5093 err = ipw2100_hw_send_command(priv, &cmd);
5094 if (err) 5094 if (err)
5095 return err; 5095 return err;
5096 5096
5097 priv->short_retry_limit = retry; 5097 priv->short_retry_limit = retry;
5098 5098
5099 return 0; 5099 return 0;
5100 } 5100 }
5101 5101
5102 static int ipw2100_set_long_retry(struct ipw2100_priv *priv, u32 retry) 5102 static int ipw2100_set_long_retry(struct ipw2100_priv *priv, u32 retry)
5103 { 5103 {
5104 struct host_command cmd = { 5104 struct host_command cmd = {
5105 .host_command = LONG_RETRY_LIMIT, 5105 .host_command = LONG_RETRY_LIMIT,
5106 .host_command_sequence = 0, 5106 .host_command_sequence = 0,
5107 .host_command_length = 4 5107 .host_command_length = 4
5108 }; 5108 };
5109 int err; 5109 int err;
5110 5110
5111 cmd.host_command_parameters[0] = retry; 5111 cmd.host_command_parameters[0] = retry;
5112 5112
5113 err = ipw2100_hw_send_command(priv, &cmd); 5113 err = ipw2100_hw_send_command(priv, &cmd);
5114 if (err) 5114 if (err)
5115 return err; 5115 return err;
5116 5116
5117 priv->long_retry_limit = retry; 5117 priv->long_retry_limit = retry;
5118 5118
5119 return 0; 5119 return 0;
5120 } 5120 }
5121 5121
5122 static int ipw2100_set_mandatory_bssid(struct ipw2100_priv *priv, u8 * bssid, 5122 static int ipw2100_set_mandatory_bssid(struct ipw2100_priv *priv, u8 * bssid,
5123 int batch_mode) 5123 int batch_mode)
5124 { 5124 {
5125 struct host_command cmd = { 5125 struct host_command cmd = {
5126 .host_command = MANDATORY_BSSID, 5126 .host_command = MANDATORY_BSSID,
5127 .host_command_sequence = 0, 5127 .host_command_sequence = 0,
5128 .host_command_length = (bssid == NULL) ? 0 : ETH_ALEN 5128 .host_command_length = (bssid == NULL) ? 0 : ETH_ALEN
5129 }; 5129 };
5130 int err; 5130 int err;
5131 5131
5132 #ifdef CONFIG_IPW2100_DEBUG 5132 #ifdef CONFIG_IPW2100_DEBUG
5133 if (bssid != NULL) 5133 if (bssid != NULL)
5134 IPW_DEBUG_HC("MANDATORY_BSSID: %pM\n", bssid); 5134 IPW_DEBUG_HC("MANDATORY_BSSID: %pM\n", bssid);
5135 else 5135 else
5136 IPW_DEBUG_HC("MANDATORY_BSSID: <clear>\n"); 5136 IPW_DEBUG_HC("MANDATORY_BSSID: <clear>\n");
5137 #endif 5137 #endif
5138 /* if BSSID is empty then we disable mandatory bssid mode */ 5138 /* if BSSID is empty then we disable mandatory bssid mode */
5139 if (bssid != NULL) 5139 if (bssid != NULL)
5140 memcpy(cmd.host_command_parameters, bssid, ETH_ALEN); 5140 memcpy(cmd.host_command_parameters, bssid, ETH_ALEN);
5141 5141
5142 if (!batch_mode) { 5142 if (!batch_mode) {
5143 err = ipw2100_disable_adapter(priv); 5143 err = ipw2100_disable_adapter(priv);
5144 if (err) 5144 if (err)
5145 return err; 5145 return err;
5146 } 5146 }
5147 5147
5148 err = ipw2100_hw_send_command(priv, &cmd); 5148 err = ipw2100_hw_send_command(priv, &cmd);
5149 5149
5150 if (!batch_mode) 5150 if (!batch_mode)
5151 ipw2100_enable_adapter(priv); 5151 ipw2100_enable_adapter(priv);
5152 5152
5153 return err; 5153 return err;
5154 } 5154 }
5155 5155
5156 static int ipw2100_disassociate_bssid(struct ipw2100_priv *priv) 5156 static int ipw2100_disassociate_bssid(struct ipw2100_priv *priv)
5157 { 5157 {
5158 struct host_command cmd = { 5158 struct host_command cmd = {
5159 .host_command = DISASSOCIATION_BSSID, 5159 .host_command = DISASSOCIATION_BSSID,
5160 .host_command_sequence = 0, 5160 .host_command_sequence = 0,
5161 .host_command_length = ETH_ALEN 5161 .host_command_length = ETH_ALEN
5162 }; 5162 };
5163 int err; 5163 int err;
5164 int len; 5164 int len;
5165 5165
5166 IPW_DEBUG_HC("DISASSOCIATION_BSSID\n"); 5166 IPW_DEBUG_HC("DISASSOCIATION_BSSID\n");
5167 5167
5168 len = ETH_ALEN; 5168 len = ETH_ALEN;
5169 /* The Firmware currently ignores the BSSID and just disassociates from 5169 /* The Firmware currently ignores the BSSID and just disassociates from
5170 * the currently associated AP -- but in the off chance that a future 5170 * the currently associated AP -- but in the off chance that a future
5171 * firmware does use the BSSID provided here, we go ahead and try and 5171 * firmware does use the BSSID provided here, we go ahead and try and
5172 * set it to the currently associated AP's BSSID */ 5172 * set it to the currently associated AP's BSSID */
5173 memcpy(cmd.host_command_parameters, priv->bssid, ETH_ALEN); 5173 memcpy(cmd.host_command_parameters, priv->bssid, ETH_ALEN);
5174 5174
5175 err = ipw2100_hw_send_command(priv, &cmd); 5175 err = ipw2100_hw_send_command(priv, &cmd);
5176 5176
5177 return err; 5177 return err;
5178 } 5178 }
5179 5179
5180 static int ipw2100_set_wpa_ie(struct ipw2100_priv *, 5180 static int ipw2100_set_wpa_ie(struct ipw2100_priv *,
5181 struct ipw2100_wpa_assoc_frame *, int) 5181 struct ipw2100_wpa_assoc_frame *, int)
5182 __attribute__ ((unused)); 5182 __attribute__ ((unused));
5183 5183
5184 static int ipw2100_set_wpa_ie(struct ipw2100_priv *priv, 5184 static int ipw2100_set_wpa_ie(struct ipw2100_priv *priv,
5185 struct ipw2100_wpa_assoc_frame *wpa_frame, 5185 struct ipw2100_wpa_assoc_frame *wpa_frame,
5186 int batch_mode) 5186 int batch_mode)
5187 { 5187 {
5188 struct host_command cmd = { 5188 struct host_command cmd = {
5189 .host_command = SET_WPA_IE, 5189 .host_command = SET_WPA_IE,
5190 .host_command_sequence = 0, 5190 .host_command_sequence = 0,
5191 .host_command_length = sizeof(struct ipw2100_wpa_assoc_frame), 5191 .host_command_length = sizeof(struct ipw2100_wpa_assoc_frame),
5192 }; 5192 };
5193 int err; 5193 int err;
5194 5194
5195 IPW_DEBUG_HC("SET_WPA_IE\n"); 5195 IPW_DEBUG_HC("SET_WPA_IE\n");
5196 5196
5197 if (!batch_mode) { 5197 if (!batch_mode) {
5198 err = ipw2100_disable_adapter(priv); 5198 err = ipw2100_disable_adapter(priv);
5199 if (err) 5199 if (err)
5200 return err; 5200 return err;
5201 } 5201 }
5202 5202
5203 memcpy(cmd.host_command_parameters, wpa_frame, 5203 memcpy(cmd.host_command_parameters, wpa_frame,
5204 sizeof(struct ipw2100_wpa_assoc_frame)); 5204 sizeof(struct ipw2100_wpa_assoc_frame));
5205 5205
5206 err = ipw2100_hw_send_command(priv, &cmd); 5206 err = ipw2100_hw_send_command(priv, &cmd);
5207 5207
5208 if (!batch_mode) { 5208 if (!batch_mode) {
5209 if (ipw2100_enable_adapter(priv)) 5209 if (ipw2100_enable_adapter(priv))
5210 err = -EIO; 5210 err = -EIO;
5211 } 5211 }
5212 5212
5213 return err; 5213 return err;
5214 } 5214 }
5215 5215
5216 struct security_info_params { 5216 struct security_info_params {
5217 u32 allowed_ciphers; 5217 u32 allowed_ciphers;
5218 u16 version; 5218 u16 version;
5219 u8 auth_mode; 5219 u8 auth_mode;
5220 u8 replay_counters_number; 5220 u8 replay_counters_number;
5221 u8 unicast_using_group; 5221 u8 unicast_using_group;
5222 } __packed; 5222 } __packed;
5223 5223
5224 static int ipw2100_set_security_information(struct ipw2100_priv *priv, 5224 static int ipw2100_set_security_information(struct ipw2100_priv *priv,
5225 int auth_mode, 5225 int auth_mode,
5226 int security_level, 5226 int security_level,
5227 int unicast_using_group, 5227 int unicast_using_group,
5228 int batch_mode) 5228 int batch_mode)
5229 { 5229 {
5230 struct host_command cmd = { 5230 struct host_command cmd = {
5231 .host_command = SET_SECURITY_INFORMATION, 5231 .host_command = SET_SECURITY_INFORMATION,
5232 .host_command_sequence = 0, 5232 .host_command_sequence = 0,
5233 .host_command_length = sizeof(struct security_info_params) 5233 .host_command_length = sizeof(struct security_info_params)
5234 }; 5234 };
5235 struct security_info_params *security = 5235 struct security_info_params *security =
5236 (struct security_info_params *)&cmd.host_command_parameters; 5236 (struct security_info_params *)&cmd.host_command_parameters;
5237 int err; 5237 int err;
5238 memset(security, 0, sizeof(*security)); 5238 memset(security, 0, sizeof(*security));
5239 5239
5240 /* If shared key AP authentication is turned on, then we need to 5240 /* If shared key AP authentication is turned on, then we need to
5241 * configure the firmware to try and use it. 5241 * configure the firmware to try and use it.
5242 * 5242 *
5243 * Actual data encryption/decryption is handled by the host. */ 5243 * Actual data encryption/decryption is handled by the host. */
5244 security->auth_mode = auth_mode; 5244 security->auth_mode = auth_mode;
5245 security->unicast_using_group = unicast_using_group; 5245 security->unicast_using_group = unicast_using_group;
5246 5246
5247 switch (security_level) { 5247 switch (security_level) {
5248 default: 5248 default:
5249 case SEC_LEVEL_0: 5249 case SEC_LEVEL_0:
5250 security->allowed_ciphers = IPW_NONE_CIPHER; 5250 security->allowed_ciphers = IPW_NONE_CIPHER;
5251 break; 5251 break;
5252 case SEC_LEVEL_1: 5252 case SEC_LEVEL_1:
5253 security->allowed_ciphers = IPW_WEP40_CIPHER | 5253 security->allowed_ciphers = IPW_WEP40_CIPHER |
5254 IPW_WEP104_CIPHER; 5254 IPW_WEP104_CIPHER;
5255 break; 5255 break;
5256 case SEC_LEVEL_2: 5256 case SEC_LEVEL_2:
5257 security->allowed_ciphers = IPW_WEP40_CIPHER | 5257 security->allowed_ciphers = IPW_WEP40_CIPHER |
5258 IPW_WEP104_CIPHER | IPW_TKIP_CIPHER; 5258 IPW_WEP104_CIPHER | IPW_TKIP_CIPHER;
5259 break; 5259 break;
5260 case SEC_LEVEL_2_CKIP: 5260 case SEC_LEVEL_2_CKIP:
5261 security->allowed_ciphers = IPW_WEP40_CIPHER | 5261 security->allowed_ciphers = IPW_WEP40_CIPHER |
5262 IPW_WEP104_CIPHER | IPW_CKIP_CIPHER; 5262 IPW_WEP104_CIPHER | IPW_CKIP_CIPHER;
5263 break; 5263 break;
5264 case SEC_LEVEL_3: 5264 case SEC_LEVEL_3:
5265 security->allowed_ciphers = IPW_WEP40_CIPHER | 5265 security->allowed_ciphers = IPW_WEP40_CIPHER |
5266 IPW_WEP104_CIPHER | IPW_TKIP_CIPHER | IPW_CCMP_CIPHER; 5266 IPW_WEP104_CIPHER | IPW_TKIP_CIPHER | IPW_CCMP_CIPHER;
5267 break; 5267 break;
5268 } 5268 }
5269 5269
5270 IPW_DEBUG_HC 5270 IPW_DEBUG_HC
5271 ("SET_SECURITY_INFORMATION: auth:%d cipher:0x%02X (level %d)\n", 5271 ("SET_SECURITY_INFORMATION: auth:%d cipher:0x%02X (level %d)\n",
5272 security->auth_mode, security->allowed_ciphers, security_level); 5272 security->auth_mode, security->allowed_ciphers, security_level);
5273 5273
5274 security->replay_counters_number = 0; 5274 security->replay_counters_number = 0;
5275 5275
5276 if (!batch_mode) { 5276 if (!batch_mode) {
5277 err = ipw2100_disable_adapter(priv); 5277 err = ipw2100_disable_adapter(priv);
5278 if (err) 5278 if (err)
5279 return err; 5279 return err;
5280 } 5280 }
5281 5281
5282 err = ipw2100_hw_send_command(priv, &cmd); 5282 err = ipw2100_hw_send_command(priv, &cmd);
5283 5283
5284 if (!batch_mode) 5284 if (!batch_mode)
5285 ipw2100_enable_adapter(priv); 5285 ipw2100_enable_adapter(priv);
5286 5286
5287 return err; 5287 return err;
5288 } 5288 }
5289 5289
5290 static int ipw2100_set_tx_power(struct ipw2100_priv *priv, u32 tx_power) 5290 static int ipw2100_set_tx_power(struct ipw2100_priv *priv, u32 tx_power)
5291 { 5291 {
5292 struct host_command cmd = { 5292 struct host_command cmd = {
5293 .host_command = TX_POWER_INDEX, 5293 .host_command = TX_POWER_INDEX,
5294 .host_command_sequence = 0, 5294 .host_command_sequence = 0,
5295 .host_command_length = 4 5295 .host_command_length = 4
5296 }; 5296 };
5297 int err = 0; 5297 int err = 0;
5298 u32 tmp = tx_power; 5298 u32 tmp = tx_power;
5299 5299
5300 if (tx_power != IPW_TX_POWER_DEFAULT) 5300 if (tx_power != IPW_TX_POWER_DEFAULT)
5301 tmp = (tx_power - IPW_TX_POWER_MIN_DBM) * 16 / 5301 tmp = (tx_power - IPW_TX_POWER_MIN_DBM) * 16 /
5302 (IPW_TX_POWER_MAX_DBM - IPW_TX_POWER_MIN_DBM); 5302 (IPW_TX_POWER_MAX_DBM - IPW_TX_POWER_MIN_DBM);
5303 5303
5304 cmd.host_command_parameters[0] = tmp; 5304 cmd.host_command_parameters[0] = tmp;
5305 5305
5306 if (priv->ieee->iw_mode == IW_MODE_ADHOC) 5306 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
5307 err = ipw2100_hw_send_command(priv, &cmd); 5307 err = ipw2100_hw_send_command(priv, &cmd);
5308 if (!err) 5308 if (!err)
5309 priv->tx_power = tx_power; 5309 priv->tx_power = tx_power;
5310 5310
5311 return 0; 5311 return 0;
5312 } 5312 }
5313 5313
5314 static int ipw2100_set_ibss_beacon_interval(struct ipw2100_priv *priv, 5314 static int ipw2100_set_ibss_beacon_interval(struct ipw2100_priv *priv,
5315 u32 interval, int batch_mode) 5315 u32 interval, int batch_mode)
5316 { 5316 {
5317 struct host_command cmd = { 5317 struct host_command cmd = {
5318 .host_command = BEACON_INTERVAL, 5318 .host_command = BEACON_INTERVAL,
5319 .host_command_sequence = 0, 5319 .host_command_sequence = 0,
5320 .host_command_length = 4 5320 .host_command_length = 4
5321 }; 5321 };
5322 int err; 5322 int err;
5323 5323
5324 cmd.host_command_parameters[0] = interval; 5324 cmd.host_command_parameters[0] = interval;
5325 5325
5326 IPW_DEBUG_INFO("enter\n"); 5326 IPW_DEBUG_INFO("enter\n");
5327 5327
5328 if (priv->ieee->iw_mode == IW_MODE_ADHOC) { 5328 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
5329 if (!batch_mode) { 5329 if (!batch_mode) {
5330 err = ipw2100_disable_adapter(priv); 5330 err = ipw2100_disable_adapter(priv);
5331 if (err) 5331 if (err)
5332 return err; 5332 return err;
5333 } 5333 }
5334 5334
5335 ipw2100_hw_send_command(priv, &cmd); 5335 ipw2100_hw_send_command(priv, &cmd);
5336 5336
5337 if (!batch_mode) { 5337 if (!batch_mode) {
5338 err = ipw2100_enable_adapter(priv); 5338 err = ipw2100_enable_adapter(priv);
5339 if (err) 5339 if (err)
5340 return err; 5340 return err;
5341 } 5341 }
5342 } 5342 }
5343 5343
5344 IPW_DEBUG_INFO("exit\n"); 5344 IPW_DEBUG_INFO("exit\n");
5345 5345
5346 return 0; 5346 return 0;
5347 } 5347 }
5348 5348
5349 static void ipw2100_queues_initialize(struct ipw2100_priv *priv) 5349 static void ipw2100_queues_initialize(struct ipw2100_priv *priv)
5350 { 5350 {
5351 ipw2100_tx_initialize(priv); 5351 ipw2100_tx_initialize(priv);
5352 ipw2100_rx_initialize(priv); 5352 ipw2100_rx_initialize(priv);
5353 ipw2100_msg_initialize(priv); 5353 ipw2100_msg_initialize(priv);
5354 } 5354 }
5355 5355
5356 static void ipw2100_queues_free(struct ipw2100_priv *priv) 5356 static void ipw2100_queues_free(struct ipw2100_priv *priv)
5357 { 5357 {
5358 ipw2100_tx_free(priv); 5358 ipw2100_tx_free(priv);
5359 ipw2100_rx_free(priv); 5359 ipw2100_rx_free(priv);
5360 ipw2100_msg_free(priv); 5360 ipw2100_msg_free(priv);
5361 } 5361 }
5362 5362
5363 static int ipw2100_queues_allocate(struct ipw2100_priv *priv) 5363 static int ipw2100_queues_allocate(struct ipw2100_priv *priv)
5364 { 5364 {
5365 if (ipw2100_tx_allocate(priv) || 5365 if (ipw2100_tx_allocate(priv) ||
5366 ipw2100_rx_allocate(priv) || ipw2100_msg_allocate(priv)) 5366 ipw2100_rx_allocate(priv) || ipw2100_msg_allocate(priv))
5367 goto fail; 5367 goto fail;
5368 5368
5369 return 0; 5369 return 0;
5370 5370
5371 fail: 5371 fail:
5372 ipw2100_tx_free(priv); 5372 ipw2100_tx_free(priv);
5373 ipw2100_rx_free(priv); 5373 ipw2100_rx_free(priv);
5374 ipw2100_msg_free(priv); 5374 ipw2100_msg_free(priv);
5375 return -ENOMEM; 5375 return -ENOMEM;
5376 } 5376 }
5377 5377
5378 #define IPW_PRIVACY_CAPABLE 0x0008 5378 #define IPW_PRIVACY_CAPABLE 0x0008
5379 5379
5380 static int ipw2100_set_wep_flags(struct ipw2100_priv *priv, u32 flags, 5380 static int ipw2100_set_wep_flags(struct ipw2100_priv *priv, u32 flags,
5381 int batch_mode) 5381 int batch_mode)
5382 { 5382 {
5383 struct host_command cmd = { 5383 struct host_command cmd = {
5384 .host_command = WEP_FLAGS, 5384 .host_command = WEP_FLAGS,
5385 .host_command_sequence = 0, 5385 .host_command_sequence = 0,
5386 .host_command_length = 4 5386 .host_command_length = 4
5387 }; 5387 };
5388 int err; 5388 int err;
5389 5389
5390 cmd.host_command_parameters[0] = flags; 5390 cmd.host_command_parameters[0] = flags;
5391 5391
5392 IPW_DEBUG_HC("WEP_FLAGS: flags = 0x%08X\n", flags); 5392 IPW_DEBUG_HC("WEP_FLAGS: flags = 0x%08X\n", flags);
5393 5393
5394 if (!batch_mode) { 5394 if (!batch_mode) {
5395 err = ipw2100_disable_adapter(priv); 5395 err = ipw2100_disable_adapter(priv);
5396 if (err) { 5396 if (err) {
5397 printk(KERN_ERR DRV_NAME 5397 printk(KERN_ERR DRV_NAME
5398 ": %s: Could not disable adapter %d\n", 5398 ": %s: Could not disable adapter %d\n",
5399 priv->net_dev->name, err); 5399 priv->net_dev->name, err);
5400 return err; 5400 return err;
5401 } 5401 }
5402 } 5402 }
5403 5403
5404 /* send cmd to firmware */ 5404 /* send cmd to firmware */
5405 err = ipw2100_hw_send_command(priv, &cmd); 5405 err = ipw2100_hw_send_command(priv, &cmd);
5406 5406
5407 if (!batch_mode) 5407 if (!batch_mode)
5408 ipw2100_enable_adapter(priv); 5408 ipw2100_enable_adapter(priv);
5409 5409
5410 return err; 5410 return err;
5411 } 5411 }
5412 5412
5413 struct ipw2100_wep_key { 5413 struct ipw2100_wep_key {
5414 u8 idx; 5414 u8 idx;
5415 u8 len; 5415 u8 len;
5416 u8 key[13]; 5416 u8 key[13];
5417 }; 5417 };
5418 5418
5419 /* Macros to ease up priting WEP keys */ 5419 /* Macros to ease up priting WEP keys */
5420 #define WEP_FMT_64 "%02X%02X%02X%02X-%02X" 5420 #define WEP_FMT_64 "%02X%02X%02X%02X-%02X"
5421 #define WEP_FMT_128 "%02X%02X%02X%02X-%02X%02X%02X%02X-%02X%02X%02X" 5421 #define WEP_FMT_128 "%02X%02X%02X%02X-%02X%02X%02X%02X-%02X%02X%02X"
5422 #define WEP_STR_64(x) x[0],x[1],x[2],x[3],x[4] 5422 #define WEP_STR_64(x) x[0],x[1],x[2],x[3],x[4]
5423 #define WEP_STR_128(x) x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],x[8],x[9],x[10] 5423 #define WEP_STR_128(x) x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],x[8],x[9],x[10]
5424 5424
5425 /** 5425 /**
5426 * Set a the wep key 5426 * Set a the wep key
5427 * 5427 *
5428 * @priv: struct to work on 5428 * @priv: struct to work on
5429 * @idx: index of the key we want to set 5429 * @idx: index of the key we want to set
5430 * @key: ptr to the key data to set 5430 * @key: ptr to the key data to set
5431 * @len: length of the buffer at @key 5431 * @len: length of the buffer at @key
5432 * @batch_mode: FIXME perform the operation in batch mode, not 5432 * @batch_mode: FIXME perform the operation in batch mode, not
5433 * disabling the device. 5433 * disabling the device.
5434 * 5434 *
5435 * @returns 0 if OK, < 0 errno code on error. 5435 * @returns 0 if OK, < 0 errno code on error.
5436 * 5436 *
5437 * Fill out a command structure with the new wep key, length an 5437 * Fill out a command structure with the new wep key, length an
5438 * index and send it down the wire. 5438 * index and send it down the wire.
5439 */ 5439 */
5440 static int ipw2100_set_key(struct ipw2100_priv *priv, 5440 static int ipw2100_set_key(struct ipw2100_priv *priv,
5441 int idx, char *key, int len, int batch_mode) 5441 int idx, char *key, int len, int batch_mode)
5442 { 5442 {
5443 int keylen = len ? (len <= 5 ? 5 : 13) : 0; 5443 int keylen = len ? (len <= 5 ? 5 : 13) : 0;
5444 struct host_command cmd = { 5444 struct host_command cmd = {
5445 .host_command = WEP_KEY_INFO, 5445 .host_command = WEP_KEY_INFO,
5446 .host_command_sequence = 0, 5446 .host_command_sequence = 0,
5447 .host_command_length = sizeof(struct ipw2100_wep_key), 5447 .host_command_length = sizeof(struct ipw2100_wep_key),
5448 }; 5448 };
5449 struct ipw2100_wep_key *wep_key = (void *)cmd.host_command_parameters; 5449 struct ipw2100_wep_key *wep_key = (void *)cmd.host_command_parameters;
5450 int err; 5450 int err;
5451 5451
5452 IPW_DEBUG_HC("WEP_KEY_INFO: index = %d, len = %d/%d\n", 5452 IPW_DEBUG_HC("WEP_KEY_INFO: index = %d, len = %d/%d\n",
5453 idx, keylen, len); 5453 idx, keylen, len);
5454 5454
5455 /* NOTE: We don't check cached values in case the firmware was reset 5455 /* NOTE: We don't check cached values in case the firmware was reset
5456 * or some other problem is occurring. If the user is setting the key, 5456 * or some other problem is occurring. If the user is setting the key,
5457 * then we push the change */ 5457 * then we push the change */
5458 5458
5459 wep_key->idx = idx; 5459 wep_key->idx = idx;
5460 wep_key->len = keylen; 5460 wep_key->len = keylen;
5461 5461
5462 if (keylen) { 5462 if (keylen) {
5463 memcpy(wep_key->key, key, len); 5463 memcpy(wep_key->key, key, len);
5464 memset(wep_key->key + len, 0, keylen - len); 5464 memset(wep_key->key + len, 0, keylen - len);
5465 } 5465 }
5466 5466
5467 /* Will be optimized out on debug not being configured in */ 5467 /* Will be optimized out on debug not being configured in */
5468 if (keylen == 0) 5468 if (keylen == 0)
5469 IPW_DEBUG_WEP("%s: Clearing key %d\n", 5469 IPW_DEBUG_WEP("%s: Clearing key %d\n",
5470 priv->net_dev->name, wep_key->idx); 5470 priv->net_dev->name, wep_key->idx);
5471 else if (keylen == 5) 5471 else if (keylen == 5)
5472 IPW_DEBUG_WEP("%s: idx: %d, len: %d key: " WEP_FMT_64 "\n", 5472 IPW_DEBUG_WEP("%s: idx: %d, len: %d key: " WEP_FMT_64 "\n",
5473 priv->net_dev->name, wep_key->idx, wep_key->len, 5473 priv->net_dev->name, wep_key->idx, wep_key->len,
5474 WEP_STR_64(wep_key->key)); 5474 WEP_STR_64(wep_key->key));
5475 else 5475 else
5476 IPW_DEBUG_WEP("%s: idx: %d, len: %d key: " WEP_FMT_128 5476 IPW_DEBUG_WEP("%s: idx: %d, len: %d key: " WEP_FMT_128
5477 "\n", 5477 "\n",
5478 priv->net_dev->name, wep_key->idx, wep_key->len, 5478 priv->net_dev->name, wep_key->idx, wep_key->len,
5479 WEP_STR_128(wep_key->key)); 5479 WEP_STR_128(wep_key->key));
5480 5480
5481 if (!batch_mode) { 5481 if (!batch_mode) {
5482 err = ipw2100_disable_adapter(priv); 5482 err = ipw2100_disable_adapter(priv);
5483 /* FIXME: IPG: shouldn't this prink be in _disable_adapter()? */ 5483 /* FIXME: IPG: shouldn't this prink be in _disable_adapter()? */
5484 if (err) { 5484 if (err) {
5485 printk(KERN_ERR DRV_NAME 5485 printk(KERN_ERR DRV_NAME
5486 ": %s: Could not disable adapter %d\n", 5486 ": %s: Could not disable adapter %d\n",
5487 priv->net_dev->name, err); 5487 priv->net_dev->name, err);
5488 return err; 5488 return err;
5489 } 5489 }
5490 } 5490 }
5491 5491
5492 /* send cmd to firmware */ 5492 /* send cmd to firmware */
5493 err = ipw2100_hw_send_command(priv, &cmd); 5493 err = ipw2100_hw_send_command(priv, &cmd);
5494 5494
5495 if (!batch_mode) { 5495 if (!batch_mode) {
5496 int err2 = ipw2100_enable_adapter(priv); 5496 int err2 = ipw2100_enable_adapter(priv);
5497 if (err == 0) 5497 if (err == 0)
5498 err = err2; 5498 err = err2;
5499 } 5499 }
5500 return err; 5500 return err;
5501 } 5501 }
5502 5502
5503 static int ipw2100_set_key_index(struct ipw2100_priv *priv, 5503 static int ipw2100_set_key_index(struct ipw2100_priv *priv,
5504 int idx, int batch_mode) 5504 int idx, int batch_mode)
5505 { 5505 {
5506 struct host_command cmd = { 5506 struct host_command cmd = {
5507 .host_command = WEP_KEY_INDEX, 5507 .host_command = WEP_KEY_INDEX,
5508 .host_command_sequence = 0, 5508 .host_command_sequence = 0,
5509 .host_command_length = 4, 5509 .host_command_length = 4,
5510 .host_command_parameters = {idx}, 5510 .host_command_parameters = {idx},
5511 }; 5511 };
5512 int err; 5512 int err;
5513 5513
5514 IPW_DEBUG_HC("WEP_KEY_INDEX: index = %d\n", idx); 5514 IPW_DEBUG_HC("WEP_KEY_INDEX: index = %d\n", idx);
5515 5515
5516 if (idx < 0 || idx > 3) 5516 if (idx < 0 || idx > 3)
5517 return -EINVAL; 5517 return -EINVAL;
5518 5518
5519 if (!batch_mode) { 5519 if (!batch_mode) {
5520 err = ipw2100_disable_adapter(priv); 5520 err = ipw2100_disable_adapter(priv);
5521 if (err) { 5521 if (err) {
5522 printk(KERN_ERR DRV_NAME 5522 printk(KERN_ERR DRV_NAME
5523 ": %s: Could not disable adapter %d\n", 5523 ": %s: Could not disable adapter %d\n",
5524 priv->net_dev->name, err); 5524 priv->net_dev->name, err);
5525 return err; 5525 return err;
5526 } 5526 }
5527 } 5527 }
5528 5528
5529 /* send cmd to firmware */ 5529 /* send cmd to firmware */
5530 err = ipw2100_hw_send_command(priv, &cmd); 5530 err = ipw2100_hw_send_command(priv, &cmd);
5531 5531
5532 if (!batch_mode) 5532 if (!batch_mode)
5533 ipw2100_enable_adapter(priv); 5533 ipw2100_enable_adapter(priv);
5534 5534
5535 return err; 5535 return err;
5536 } 5536 }
5537 5537
5538 static int ipw2100_configure_security(struct ipw2100_priv *priv, int batch_mode) 5538 static int ipw2100_configure_security(struct ipw2100_priv *priv, int batch_mode)
5539 { 5539 {
5540 int i, err, auth_mode, sec_level, use_group; 5540 int i, err, auth_mode, sec_level, use_group;
5541 5541
5542 if (!(priv->status & STATUS_RUNNING)) 5542 if (!(priv->status & STATUS_RUNNING))
5543 return 0; 5543 return 0;
5544 5544
5545 if (!batch_mode) { 5545 if (!batch_mode) {
5546 err = ipw2100_disable_adapter(priv); 5546 err = ipw2100_disable_adapter(priv);
5547 if (err) 5547 if (err)
5548 return err; 5548 return err;
5549 } 5549 }
5550 5550
5551 if (!priv->ieee->sec.enabled) { 5551 if (!priv->ieee->sec.enabled) {
5552 err = 5552 err =
5553 ipw2100_set_security_information(priv, IPW_AUTH_OPEN, 5553 ipw2100_set_security_information(priv, IPW_AUTH_OPEN,
5554 SEC_LEVEL_0, 0, 1); 5554 SEC_LEVEL_0, 0, 1);
5555 } else { 5555 } else {
5556 auth_mode = IPW_AUTH_OPEN; 5556 auth_mode = IPW_AUTH_OPEN;
5557 if (priv->ieee->sec.flags & SEC_AUTH_MODE) { 5557 if (priv->ieee->sec.flags & SEC_AUTH_MODE) {
5558 if (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY) 5558 if (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY)
5559 auth_mode = IPW_AUTH_SHARED; 5559 auth_mode = IPW_AUTH_SHARED;
5560 else if (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP) 5560 else if (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP)
5561 auth_mode = IPW_AUTH_LEAP_CISCO_ID; 5561 auth_mode = IPW_AUTH_LEAP_CISCO_ID;
5562 } 5562 }
5563 5563
5564 sec_level = SEC_LEVEL_0; 5564 sec_level = SEC_LEVEL_0;
5565 if (priv->ieee->sec.flags & SEC_LEVEL) 5565 if (priv->ieee->sec.flags & SEC_LEVEL)
5566 sec_level = priv->ieee->sec.level; 5566 sec_level = priv->ieee->sec.level;
5567 5567
5568 use_group = 0; 5568 use_group = 0;
5569 if (priv->ieee->sec.flags & SEC_UNICAST_GROUP) 5569 if (priv->ieee->sec.flags & SEC_UNICAST_GROUP)
5570 use_group = priv->ieee->sec.unicast_uses_group; 5570 use_group = priv->ieee->sec.unicast_uses_group;
5571 5571
5572 err = 5572 err =
5573 ipw2100_set_security_information(priv, auth_mode, sec_level, 5573 ipw2100_set_security_information(priv, auth_mode, sec_level,
5574 use_group, 1); 5574 use_group, 1);
5575 } 5575 }
5576 5576
5577 if (err) 5577 if (err)
5578 goto exit; 5578 goto exit;
5579 5579
5580 if (priv->ieee->sec.enabled) { 5580 if (priv->ieee->sec.enabled) {
5581 for (i = 0; i < 4; i++) { 5581 for (i = 0; i < 4; i++) {
5582 if (!(priv->ieee->sec.flags & (1 << i))) { 5582 if (!(priv->ieee->sec.flags & (1 << i))) {
5583 memset(priv->ieee->sec.keys[i], 0, WEP_KEY_LEN); 5583 memset(priv->ieee->sec.keys[i], 0, WEP_KEY_LEN);
5584 priv->ieee->sec.key_sizes[i] = 0; 5584 priv->ieee->sec.key_sizes[i] = 0;
5585 } else { 5585 } else {
5586 err = ipw2100_set_key(priv, i, 5586 err = ipw2100_set_key(priv, i,
5587 priv->ieee->sec.keys[i], 5587 priv->ieee->sec.keys[i],
5588 priv->ieee->sec. 5588 priv->ieee->sec.
5589 key_sizes[i], 1); 5589 key_sizes[i], 1);
5590 if (err) 5590 if (err)
5591 goto exit; 5591 goto exit;
5592 } 5592 }
5593 } 5593 }
5594 5594
5595 ipw2100_set_key_index(priv, priv->ieee->crypt_info.tx_keyidx, 1); 5595 ipw2100_set_key_index(priv, priv->ieee->crypt_info.tx_keyidx, 1);
5596 } 5596 }
5597 5597
5598 /* Always enable privacy so the Host can filter WEP packets if 5598 /* Always enable privacy so the Host can filter WEP packets if
5599 * encrypted data is sent up */ 5599 * encrypted data is sent up */
5600 err = 5600 err =
5601 ipw2100_set_wep_flags(priv, 5601 ipw2100_set_wep_flags(priv,
5602 priv->ieee->sec. 5602 priv->ieee->sec.
5603 enabled ? IPW_PRIVACY_CAPABLE : 0, 1); 5603 enabled ? IPW_PRIVACY_CAPABLE : 0, 1);
5604 if (err) 5604 if (err)
5605 goto exit; 5605 goto exit;
5606 5606
5607 priv->status &= ~STATUS_SECURITY_UPDATED; 5607 priv->status &= ~STATUS_SECURITY_UPDATED;
5608 5608
5609 exit: 5609 exit:
5610 if (!batch_mode) 5610 if (!batch_mode)
5611 ipw2100_enable_adapter(priv); 5611 ipw2100_enable_adapter(priv);
5612 5612
5613 return err; 5613 return err;
5614 } 5614 }
5615 5615
5616 static void ipw2100_security_work(struct work_struct *work) 5616 static void ipw2100_security_work(struct work_struct *work)
5617 { 5617 {
5618 struct ipw2100_priv *priv = 5618 struct ipw2100_priv *priv =
5619 container_of(work, struct ipw2100_priv, security_work.work); 5619 container_of(work, struct ipw2100_priv, security_work.work);
5620 5620
5621 /* If we happen to have reconnected before we get a chance to 5621 /* If we happen to have reconnected before we get a chance to
5622 * process this, then update the security settings--which causes 5622 * process this, then update the security settings--which causes
5623 * a disassociation to occur */ 5623 * a disassociation to occur */
5624 if (!(priv->status & STATUS_ASSOCIATED) && 5624 if (!(priv->status & STATUS_ASSOCIATED) &&
5625 priv->status & STATUS_SECURITY_UPDATED) 5625 priv->status & STATUS_SECURITY_UPDATED)
5626 ipw2100_configure_security(priv, 0); 5626 ipw2100_configure_security(priv, 0);
5627 } 5627 }
5628 5628
5629 static void shim__set_security(struct net_device *dev, 5629 static void shim__set_security(struct net_device *dev,
5630 struct libipw_security *sec) 5630 struct libipw_security *sec)
5631 { 5631 {
5632 struct ipw2100_priv *priv = libipw_priv(dev); 5632 struct ipw2100_priv *priv = libipw_priv(dev);
5633 int i, force_update = 0; 5633 int i, force_update = 0;
5634 5634
5635 mutex_lock(&priv->action_mutex); 5635 mutex_lock(&priv->action_mutex);
5636 if (!(priv->status & STATUS_INITIALIZED)) 5636 if (!(priv->status & STATUS_INITIALIZED))
5637 goto done; 5637 goto done;
5638 5638
5639 for (i = 0; i < 4; i++) { 5639 for (i = 0; i < 4; i++) {
5640 if (sec->flags & (1 << i)) { 5640 if (sec->flags & (1 << i)) {
5641 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i]; 5641 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
5642 if (sec->key_sizes[i] == 0) 5642 if (sec->key_sizes[i] == 0)
5643 priv->ieee->sec.flags &= ~(1 << i); 5643 priv->ieee->sec.flags &= ~(1 << i);
5644 else 5644 else
5645 memcpy(priv->ieee->sec.keys[i], sec->keys[i], 5645 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
5646 sec->key_sizes[i]); 5646 sec->key_sizes[i]);
5647 if (sec->level == SEC_LEVEL_1) { 5647 if (sec->level == SEC_LEVEL_1) {
5648 priv->ieee->sec.flags |= (1 << i); 5648 priv->ieee->sec.flags |= (1 << i);
5649 priv->status |= STATUS_SECURITY_UPDATED; 5649 priv->status |= STATUS_SECURITY_UPDATED;
5650 } else 5650 } else
5651 priv->ieee->sec.flags &= ~(1 << i); 5651 priv->ieee->sec.flags &= ~(1 << i);
5652 } 5652 }
5653 } 5653 }
5654 5654
5655 if ((sec->flags & SEC_ACTIVE_KEY) && 5655 if ((sec->flags & SEC_ACTIVE_KEY) &&
5656 priv->ieee->sec.active_key != sec->active_key) { 5656 priv->ieee->sec.active_key != sec->active_key) {
5657 if (sec->active_key <= 3) { 5657 if (sec->active_key <= 3) {
5658 priv->ieee->sec.active_key = sec->active_key; 5658 priv->ieee->sec.active_key = sec->active_key;
5659 priv->ieee->sec.flags |= SEC_ACTIVE_KEY; 5659 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
5660 } else 5660 } else
5661 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY; 5661 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
5662 5662
5663 priv->status |= STATUS_SECURITY_UPDATED; 5663 priv->status |= STATUS_SECURITY_UPDATED;
5664 } 5664 }
5665 5665
5666 if ((sec->flags & SEC_AUTH_MODE) && 5666 if ((sec->flags & SEC_AUTH_MODE) &&
5667 (priv->ieee->sec.auth_mode != sec->auth_mode)) { 5667 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
5668 priv->ieee->sec.auth_mode = sec->auth_mode; 5668 priv->ieee->sec.auth_mode = sec->auth_mode;
5669 priv->ieee->sec.flags |= SEC_AUTH_MODE; 5669 priv->ieee->sec.flags |= SEC_AUTH_MODE;
5670 priv->status |= STATUS_SECURITY_UPDATED; 5670 priv->status |= STATUS_SECURITY_UPDATED;
5671 } 5671 }
5672 5672
5673 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) { 5673 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
5674 priv->ieee->sec.flags |= SEC_ENABLED; 5674 priv->ieee->sec.flags |= SEC_ENABLED;
5675 priv->ieee->sec.enabled = sec->enabled; 5675 priv->ieee->sec.enabled = sec->enabled;
5676 priv->status |= STATUS_SECURITY_UPDATED; 5676 priv->status |= STATUS_SECURITY_UPDATED;
5677 force_update = 1; 5677 force_update = 1;
5678 } 5678 }
5679 5679
5680 if (sec->flags & SEC_ENCRYPT) 5680 if (sec->flags & SEC_ENCRYPT)
5681 priv->ieee->sec.encrypt = sec->encrypt; 5681 priv->ieee->sec.encrypt = sec->encrypt;
5682 5682
5683 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) { 5683 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
5684 priv->ieee->sec.level = sec->level; 5684 priv->ieee->sec.level = sec->level;
5685 priv->ieee->sec.flags |= SEC_LEVEL; 5685 priv->ieee->sec.flags |= SEC_LEVEL;
5686 priv->status |= STATUS_SECURITY_UPDATED; 5686 priv->status |= STATUS_SECURITY_UPDATED;
5687 } 5687 }
5688 5688
5689 IPW_DEBUG_WEP("Security flags: %c %c%c%c%c %c%c%c%c\n", 5689 IPW_DEBUG_WEP("Security flags: %c %c%c%c%c %c%c%c%c\n",
5690 priv->ieee->sec.flags & (1 << 8) ? '1' : '0', 5690 priv->ieee->sec.flags & (1 << 8) ? '1' : '0',
5691 priv->ieee->sec.flags & (1 << 7) ? '1' : '0', 5691 priv->ieee->sec.flags & (1 << 7) ? '1' : '0',
5692 priv->ieee->sec.flags & (1 << 6) ? '1' : '0', 5692 priv->ieee->sec.flags & (1 << 6) ? '1' : '0',
5693 priv->ieee->sec.flags & (1 << 5) ? '1' : '0', 5693 priv->ieee->sec.flags & (1 << 5) ? '1' : '0',
5694 priv->ieee->sec.flags & (1 << 4) ? '1' : '0', 5694 priv->ieee->sec.flags & (1 << 4) ? '1' : '0',
5695 priv->ieee->sec.flags & (1 << 3) ? '1' : '0', 5695 priv->ieee->sec.flags & (1 << 3) ? '1' : '0',
5696 priv->ieee->sec.flags & (1 << 2) ? '1' : '0', 5696 priv->ieee->sec.flags & (1 << 2) ? '1' : '0',
5697 priv->ieee->sec.flags & (1 << 1) ? '1' : '0', 5697 priv->ieee->sec.flags & (1 << 1) ? '1' : '0',
5698 priv->ieee->sec.flags & (1 << 0) ? '1' : '0'); 5698 priv->ieee->sec.flags & (1 << 0) ? '1' : '0');
5699 5699
5700 /* As a temporary work around to enable WPA until we figure out why 5700 /* As a temporary work around to enable WPA until we figure out why
5701 * wpa_supplicant toggles the security capability of the driver, which 5701 * wpa_supplicant toggles the security capability of the driver, which
5702 * forces a disassocation with force_update... 5702 * forces a disassocation with force_update...
5703 * 5703 *
5704 * if (force_update || !(priv->status & STATUS_ASSOCIATED))*/ 5704 * if (force_update || !(priv->status & STATUS_ASSOCIATED))*/
5705 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING))) 5705 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
5706 ipw2100_configure_security(priv, 0); 5706 ipw2100_configure_security(priv, 0);
5707 done: 5707 done:
5708 mutex_unlock(&priv->action_mutex); 5708 mutex_unlock(&priv->action_mutex);
5709 } 5709 }
5710 5710
5711 static int ipw2100_adapter_setup(struct ipw2100_priv *priv) 5711 static int ipw2100_adapter_setup(struct ipw2100_priv *priv)
5712 { 5712 {
5713 int err; 5713 int err;
5714 int batch_mode = 1; 5714 int batch_mode = 1;
5715 u8 *bssid; 5715 u8 *bssid;
5716 5716
5717 IPW_DEBUG_INFO("enter\n"); 5717 IPW_DEBUG_INFO("enter\n");
5718 5718
5719 err = ipw2100_disable_adapter(priv); 5719 err = ipw2100_disable_adapter(priv);
5720 if (err) 5720 if (err)
5721 return err; 5721 return err;
5722 #ifdef CONFIG_IPW2100_MONITOR 5722 #ifdef CONFIG_IPW2100_MONITOR
5723 if (priv->ieee->iw_mode == IW_MODE_MONITOR) { 5723 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
5724 err = ipw2100_set_channel(priv, priv->channel, batch_mode); 5724 err = ipw2100_set_channel(priv, priv->channel, batch_mode);
5725 if (err) 5725 if (err)
5726 return err; 5726 return err;
5727 5727
5728 IPW_DEBUG_INFO("exit\n"); 5728 IPW_DEBUG_INFO("exit\n");
5729 5729
5730 return 0; 5730 return 0;
5731 } 5731 }
5732 #endif /* CONFIG_IPW2100_MONITOR */ 5732 #endif /* CONFIG_IPW2100_MONITOR */
5733 5733
5734 err = ipw2100_read_mac_address(priv); 5734 err = ipw2100_read_mac_address(priv);
5735 if (err) 5735 if (err)
5736 return -EIO; 5736 return -EIO;
5737 5737
5738 err = ipw2100_set_mac_address(priv, batch_mode); 5738 err = ipw2100_set_mac_address(priv, batch_mode);
5739 if (err) 5739 if (err)
5740 return err; 5740 return err;
5741 5741
5742 err = ipw2100_set_port_type(priv, priv->ieee->iw_mode, batch_mode); 5742 err = ipw2100_set_port_type(priv, priv->ieee->iw_mode, batch_mode);
5743 if (err) 5743 if (err)
5744 return err; 5744 return err;
5745 5745
5746 if (priv->ieee->iw_mode == IW_MODE_ADHOC) { 5746 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
5747 err = ipw2100_set_channel(priv, priv->channel, batch_mode); 5747 err = ipw2100_set_channel(priv, priv->channel, batch_mode);
5748 if (err) 5748 if (err)
5749 return err; 5749 return err;
5750 } 5750 }
5751 5751
5752 err = ipw2100_system_config(priv, batch_mode); 5752 err = ipw2100_system_config(priv, batch_mode);
5753 if (err) 5753 if (err)
5754 return err; 5754 return err;
5755 5755
5756 err = ipw2100_set_tx_rates(priv, priv->tx_rates, batch_mode); 5756 err = ipw2100_set_tx_rates(priv, priv->tx_rates, batch_mode);
5757 if (err) 5757 if (err)
5758 return err; 5758 return err;
5759 5759
5760 /* Default to power mode OFF */ 5760 /* Default to power mode OFF */
5761 err = ipw2100_set_power_mode(priv, IPW_POWER_MODE_CAM); 5761 err = ipw2100_set_power_mode(priv, IPW_POWER_MODE_CAM);
5762 if (err) 5762 if (err)
5763 return err; 5763 return err;
5764 5764
5765 err = ipw2100_set_rts_threshold(priv, priv->rts_threshold); 5765 err = ipw2100_set_rts_threshold(priv, priv->rts_threshold);
5766 if (err) 5766 if (err)
5767 return err; 5767 return err;
5768 5768
5769 if (priv->config & CFG_STATIC_BSSID) 5769 if (priv->config & CFG_STATIC_BSSID)
5770 bssid = priv->bssid; 5770 bssid = priv->bssid;
5771 else 5771 else
5772 bssid = NULL; 5772 bssid = NULL;
5773 err = ipw2100_set_mandatory_bssid(priv, bssid, batch_mode); 5773 err = ipw2100_set_mandatory_bssid(priv, bssid, batch_mode);
5774 if (err) 5774 if (err)
5775 return err; 5775 return err;
5776 5776
5777 if (priv->config & CFG_STATIC_ESSID) 5777 if (priv->config & CFG_STATIC_ESSID)
5778 err = ipw2100_set_essid(priv, priv->essid, priv->essid_len, 5778 err = ipw2100_set_essid(priv, priv->essid, priv->essid_len,
5779 batch_mode); 5779 batch_mode);
5780 else 5780 else
5781 err = ipw2100_set_essid(priv, NULL, 0, batch_mode); 5781 err = ipw2100_set_essid(priv, NULL, 0, batch_mode);
5782 if (err) 5782 if (err)
5783 return err; 5783 return err;
5784 5784
5785 err = ipw2100_configure_security(priv, batch_mode); 5785 err = ipw2100_configure_security(priv, batch_mode);
5786 if (err) 5786 if (err)
5787 return err; 5787 return err;
5788 5788
5789 if (priv->ieee->iw_mode == IW_MODE_ADHOC) { 5789 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
5790 err = 5790 err =
5791 ipw2100_set_ibss_beacon_interval(priv, 5791 ipw2100_set_ibss_beacon_interval(priv,
5792 priv->beacon_interval, 5792 priv->beacon_interval,
5793 batch_mode); 5793 batch_mode);
5794 if (err) 5794 if (err)
5795 return err; 5795 return err;
5796 5796
5797 err = ipw2100_set_tx_power(priv, priv->tx_power); 5797 err = ipw2100_set_tx_power(priv, priv->tx_power);
5798 if (err) 5798 if (err)
5799 return err; 5799 return err;
5800 } 5800 }
5801 5801
5802 /* 5802 /*
5803 err = ipw2100_set_fragmentation_threshold( 5803 err = ipw2100_set_fragmentation_threshold(
5804 priv, priv->frag_threshold, batch_mode); 5804 priv, priv->frag_threshold, batch_mode);
5805 if (err) 5805 if (err)
5806 return err; 5806 return err;
5807 */ 5807 */
5808 5808
5809 IPW_DEBUG_INFO("exit\n"); 5809 IPW_DEBUG_INFO("exit\n");
5810 5810
5811 return 0; 5811 return 0;
5812 } 5812 }
5813 5813
5814 /************************************************************************* 5814 /*************************************************************************
5815 * 5815 *
5816 * EXTERNALLY CALLED METHODS 5816 * EXTERNALLY CALLED METHODS
5817 * 5817 *
5818 *************************************************************************/ 5818 *************************************************************************/
5819 5819
5820 /* This method is called by the network layer -- not to be confused with 5820 /* This method is called by the network layer -- not to be confused with
5821 * ipw2100_set_mac_address() declared above called by this driver (and this 5821 * ipw2100_set_mac_address() declared above called by this driver (and this
5822 * method as well) to talk to the firmware */ 5822 * method as well) to talk to the firmware */
5823 static int ipw2100_set_address(struct net_device *dev, void *p) 5823 static int ipw2100_set_address(struct net_device *dev, void *p)
5824 { 5824 {
5825 struct ipw2100_priv *priv = libipw_priv(dev); 5825 struct ipw2100_priv *priv = libipw_priv(dev);
5826 struct sockaddr *addr = p; 5826 struct sockaddr *addr = p;
5827 int err = 0; 5827 int err = 0;
5828 5828
5829 if (!is_valid_ether_addr(addr->sa_data)) 5829 if (!is_valid_ether_addr(addr->sa_data))
5830 return -EADDRNOTAVAIL; 5830 return -EADDRNOTAVAIL;
5831 5831
5832 mutex_lock(&priv->action_mutex); 5832 mutex_lock(&priv->action_mutex);
5833 5833
5834 priv->config |= CFG_CUSTOM_MAC; 5834 priv->config |= CFG_CUSTOM_MAC;
5835 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN); 5835 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
5836 5836
5837 err = ipw2100_set_mac_address(priv, 0); 5837 err = ipw2100_set_mac_address(priv, 0);
5838 if (err) 5838 if (err)
5839 goto done; 5839 goto done;
5840 5840
5841 priv->reset_backoff = 0; 5841 priv->reset_backoff = 0;
5842 mutex_unlock(&priv->action_mutex); 5842 mutex_unlock(&priv->action_mutex);
5843 ipw2100_reset_adapter(&priv->reset_work.work); 5843 ipw2100_reset_adapter(&priv->reset_work.work);
5844 return 0; 5844 return 0;
5845 5845
5846 done: 5846 done:
5847 mutex_unlock(&priv->action_mutex); 5847 mutex_unlock(&priv->action_mutex);
5848 return err; 5848 return err;
5849 } 5849 }
5850 5850
5851 static int ipw2100_open(struct net_device *dev) 5851 static int ipw2100_open(struct net_device *dev)
5852 { 5852 {
5853 struct ipw2100_priv *priv = libipw_priv(dev); 5853 struct ipw2100_priv *priv = libipw_priv(dev);
5854 unsigned long flags; 5854 unsigned long flags;
5855 IPW_DEBUG_INFO("dev->open\n"); 5855 IPW_DEBUG_INFO("dev->open\n");
5856 5856
5857 spin_lock_irqsave(&priv->low_lock, flags); 5857 spin_lock_irqsave(&priv->low_lock, flags);
5858 if (priv->status & STATUS_ASSOCIATED) { 5858 if (priv->status & STATUS_ASSOCIATED) {
5859 netif_carrier_on(dev); 5859 netif_carrier_on(dev);
5860 netif_start_queue(dev); 5860 netif_start_queue(dev);
5861 } 5861 }
5862 spin_unlock_irqrestore(&priv->low_lock, flags); 5862 spin_unlock_irqrestore(&priv->low_lock, flags);
5863 5863
5864 return 0; 5864 return 0;
5865 } 5865 }
5866 5866
5867 static int ipw2100_close(struct net_device *dev) 5867 static int ipw2100_close(struct net_device *dev)
5868 { 5868 {
5869 struct ipw2100_priv *priv = libipw_priv(dev); 5869 struct ipw2100_priv *priv = libipw_priv(dev);
5870 unsigned long flags; 5870 unsigned long flags;
5871 struct list_head *element; 5871 struct list_head *element;
5872 struct ipw2100_tx_packet *packet; 5872 struct ipw2100_tx_packet *packet;
5873 5873
5874 IPW_DEBUG_INFO("enter\n"); 5874 IPW_DEBUG_INFO("enter\n");
5875 5875
5876 spin_lock_irqsave(&priv->low_lock, flags); 5876 spin_lock_irqsave(&priv->low_lock, flags);
5877 5877
5878 if (priv->status & STATUS_ASSOCIATED) 5878 if (priv->status & STATUS_ASSOCIATED)
5879 netif_carrier_off(dev); 5879 netif_carrier_off(dev);
5880 netif_stop_queue(dev); 5880 netif_stop_queue(dev);
5881 5881
5882 /* Flush the TX queue ... */ 5882 /* Flush the TX queue ... */
5883 while (!list_empty(&priv->tx_pend_list)) { 5883 while (!list_empty(&priv->tx_pend_list)) {
5884 element = priv->tx_pend_list.next; 5884 element = priv->tx_pend_list.next;
5885 packet = list_entry(element, struct ipw2100_tx_packet, list); 5885 packet = list_entry(element, struct ipw2100_tx_packet, list);
5886 5886
5887 list_del(element); 5887 list_del(element);
5888 DEC_STAT(&priv->tx_pend_stat); 5888 DEC_STAT(&priv->tx_pend_stat);
5889 5889
5890 libipw_txb_free(packet->info.d_struct.txb); 5890 libipw_txb_free(packet->info.d_struct.txb);
5891 packet->info.d_struct.txb = NULL; 5891 packet->info.d_struct.txb = NULL;
5892 5892
5893 list_add_tail(element, &priv->tx_free_list); 5893 list_add_tail(element, &priv->tx_free_list);
5894 INC_STAT(&priv->tx_free_stat); 5894 INC_STAT(&priv->tx_free_stat);
5895 } 5895 }
5896 spin_unlock_irqrestore(&priv->low_lock, flags); 5896 spin_unlock_irqrestore(&priv->low_lock, flags);
5897 5897
5898 IPW_DEBUG_INFO("exit\n"); 5898 IPW_DEBUG_INFO("exit\n");
5899 5899
5900 return 0; 5900 return 0;
5901 } 5901 }
5902 5902
5903 /* 5903 /*
5904 * TODO: Fix this function... its just wrong 5904 * TODO: Fix this function... its just wrong
5905 */ 5905 */
5906 static void ipw2100_tx_timeout(struct net_device *dev) 5906 static void ipw2100_tx_timeout(struct net_device *dev)
5907 { 5907 {
5908 struct ipw2100_priv *priv = libipw_priv(dev); 5908 struct ipw2100_priv *priv = libipw_priv(dev);
5909 5909
5910 dev->stats.tx_errors++; 5910 dev->stats.tx_errors++;
5911 5911
5912 #ifdef CONFIG_IPW2100_MONITOR 5912 #ifdef CONFIG_IPW2100_MONITOR
5913 if (priv->ieee->iw_mode == IW_MODE_MONITOR) 5913 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
5914 return; 5914 return;
5915 #endif 5915 #endif
5916 5916
5917 IPW_DEBUG_INFO("%s: TX timed out. Scheduling firmware restart.\n", 5917 IPW_DEBUG_INFO("%s: TX timed out. Scheduling firmware restart.\n",
5918 dev->name); 5918 dev->name);
5919 schedule_reset(priv); 5919 schedule_reset(priv);
5920 } 5920 }
5921 5921
5922 static int ipw2100_wpa_enable(struct ipw2100_priv *priv, int value) 5922 static int ipw2100_wpa_enable(struct ipw2100_priv *priv, int value)
5923 { 5923 {
5924 /* This is called when wpa_supplicant loads and closes the driver 5924 /* This is called when wpa_supplicant loads and closes the driver
5925 * interface. */ 5925 * interface. */
5926 priv->ieee->wpa_enabled = value; 5926 priv->ieee->wpa_enabled = value;
5927 return 0; 5927 return 0;
5928 } 5928 }
5929 5929
5930 static int ipw2100_wpa_set_auth_algs(struct ipw2100_priv *priv, int value) 5930 static int ipw2100_wpa_set_auth_algs(struct ipw2100_priv *priv, int value)
5931 { 5931 {
5932 5932
5933 struct libipw_device *ieee = priv->ieee; 5933 struct libipw_device *ieee = priv->ieee;
5934 struct libipw_security sec = { 5934 struct libipw_security sec = {
5935 .flags = SEC_AUTH_MODE, 5935 .flags = SEC_AUTH_MODE,
5936 }; 5936 };
5937 int ret = 0; 5937 int ret = 0;
5938 5938
5939 if (value & IW_AUTH_ALG_SHARED_KEY) { 5939 if (value & IW_AUTH_ALG_SHARED_KEY) {
5940 sec.auth_mode = WLAN_AUTH_SHARED_KEY; 5940 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
5941 ieee->open_wep = 0; 5941 ieee->open_wep = 0;
5942 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) { 5942 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
5943 sec.auth_mode = WLAN_AUTH_OPEN; 5943 sec.auth_mode = WLAN_AUTH_OPEN;
5944 ieee->open_wep = 1; 5944 ieee->open_wep = 1;
5945 } else if (value & IW_AUTH_ALG_LEAP) { 5945 } else if (value & IW_AUTH_ALG_LEAP) {
5946 sec.auth_mode = WLAN_AUTH_LEAP; 5946 sec.auth_mode = WLAN_AUTH_LEAP;
5947 ieee->open_wep = 1; 5947 ieee->open_wep = 1;
5948 } else 5948 } else
5949 return -EINVAL; 5949 return -EINVAL;
5950 5950
5951 if (ieee->set_security) 5951 if (ieee->set_security)
5952 ieee->set_security(ieee->dev, &sec); 5952 ieee->set_security(ieee->dev, &sec);
5953 else 5953 else
5954 ret = -EOPNOTSUPP; 5954 ret = -EOPNOTSUPP;
5955 5955
5956 return ret; 5956 return ret;
5957 } 5957 }
5958 5958
5959 static void ipw2100_wpa_assoc_frame(struct ipw2100_priv *priv, 5959 static void ipw2100_wpa_assoc_frame(struct ipw2100_priv *priv,
5960 char *wpa_ie, int wpa_ie_len) 5960 char *wpa_ie, int wpa_ie_len)
5961 { 5961 {
5962 5962
5963 struct ipw2100_wpa_assoc_frame frame; 5963 struct ipw2100_wpa_assoc_frame frame;
5964 5964
5965 frame.fixed_ie_mask = 0; 5965 frame.fixed_ie_mask = 0;
5966 5966
5967 /* copy WPA IE */ 5967 /* copy WPA IE */
5968 memcpy(frame.var_ie, wpa_ie, wpa_ie_len); 5968 memcpy(frame.var_ie, wpa_ie, wpa_ie_len);
5969 frame.var_ie_len = wpa_ie_len; 5969 frame.var_ie_len = wpa_ie_len;
5970 5970
5971 /* make sure WPA is enabled */ 5971 /* make sure WPA is enabled */
5972 ipw2100_wpa_enable(priv, 1); 5972 ipw2100_wpa_enable(priv, 1);
5973 ipw2100_set_wpa_ie(priv, &frame, 0); 5973 ipw2100_set_wpa_ie(priv, &frame, 0);
5974 } 5974 }
5975 5975
5976 static void ipw_ethtool_get_drvinfo(struct net_device *dev, 5976 static void ipw_ethtool_get_drvinfo(struct net_device *dev,
5977 struct ethtool_drvinfo *info) 5977 struct ethtool_drvinfo *info)
5978 { 5978 {
5979 struct ipw2100_priv *priv = libipw_priv(dev); 5979 struct ipw2100_priv *priv = libipw_priv(dev);
5980 char fw_ver[64], ucode_ver[64]; 5980 char fw_ver[64], ucode_ver[64];
5981 5981
5982 strcpy(info->driver, DRV_NAME); 5982 strcpy(info->driver, DRV_NAME);
5983 strcpy(info->version, DRV_VERSION); 5983 strcpy(info->version, DRV_VERSION);
5984 5984
5985 ipw2100_get_fwversion(priv, fw_ver, sizeof(fw_ver)); 5985 ipw2100_get_fwversion(priv, fw_ver, sizeof(fw_ver));
5986 ipw2100_get_ucodeversion(priv, ucode_ver, sizeof(ucode_ver)); 5986 ipw2100_get_ucodeversion(priv, ucode_ver, sizeof(ucode_ver));
5987 5987
5988 snprintf(info->fw_version, sizeof(info->fw_version), "%s:%d:%s", 5988 snprintf(info->fw_version, sizeof(info->fw_version), "%s:%d:%s",
5989 fw_ver, priv->eeprom_version, ucode_ver); 5989 fw_ver, priv->eeprom_version, ucode_ver);
5990 5990
5991 strcpy(info->bus_info, pci_name(priv->pci_dev)); 5991 strcpy(info->bus_info, pci_name(priv->pci_dev));
5992 } 5992 }
5993 5993
5994 static u32 ipw2100_ethtool_get_link(struct net_device *dev) 5994 static u32 ipw2100_ethtool_get_link(struct net_device *dev)
5995 { 5995 {
5996 struct ipw2100_priv *priv = libipw_priv(dev); 5996 struct ipw2100_priv *priv = libipw_priv(dev);
5997 return (priv->status & STATUS_ASSOCIATED) ? 1 : 0; 5997 return (priv->status & STATUS_ASSOCIATED) ? 1 : 0;
5998 } 5998 }
5999 5999
6000 static const struct ethtool_ops ipw2100_ethtool_ops = { 6000 static const struct ethtool_ops ipw2100_ethtool_ops = {
6001 .get_link = ipw2100_ethtool_get_link, 6001 .get_link = ipw2100_ethtool_get_link,
6002 .get_drvinfo = ipw_ethtool_get_drvinfo, 6002 .get_drvinfo = ipw_ethtool_get_drvinfo,
6003 }; 6003 };
6004 6004
6005 static void ipw2100_hang_check(struct work_struct *work) 6005 static void ipw2100_hang_check(struct work_struct *work)
6006 { 6006 {
6007 struct ipw2100_priv *priv = 6007 struct ipw2100_priv *priv =
6008 container_of(work, struct ipw2100_priv, hang_check.work); 6008 container_of(work, struct ipw2100_priv, hang_check.work);
6009 unsigned long flags; 6009 unsigned long flags;
6010 u32 rtc = 0xa5a5a5a5; 6010 u32 rtc = 0xa5a5a5a5;
6011 u32 len = sizeof(rtc); 6011 u32 len = sizeof(rtc);
6012 int restart = 0; 6012 int restart = 0;
6013 6013
6014 spin_lock_irqsave(&priv->low_lock, flags); 6014 spin_lock_irqsave(&priv->low_lock, flags);
6015 6015
6016 if (priv->fatal_error != 0) { 6016 if (priv->fatal_error != 0) {
6017 /* If fatal_error is set then we need to restart */ 6017 /* If fatal_error is set then we need to restart */
6018 IPW_DEBUG_INFO("%s: Hardware fatal error detected.\n", 6018 IPW_DEBUG_INFO("%s: Hardware fatal error detected.\n",
6019 priv->net_dev->name); 6019 priv->net_dev->name);
6020 6020
6021 restart = 1; 6021 restart = 1;
6022 } else if (ipw2100_get_ordinal(priv, IPW_ORD_RTC_TIME, &rtc, &len) || 6022 } else if (ipw2100_get_ordinal(priv, IPW_ORD_RTC_TIME, &rtc, &len) ||
6023 (rtc == priv->last_rtc)) { 6023 (rtc == priv->last_rtc)) {
6024 /* Check if firmware is hung */ 6024 /* Check if firmware is hung */
6025 IPW_DEBUG_INFO("%s: Firmware RTC stalled.\n", 6025 IPW_DEBUG_INFO("%s: Firmware RTC stalled.\n",
6026 priv->net_dev->name); 6026 priv->net_dev->name);
6027 6027
6028 restart = 1; 6028 restart = 1;
6029 } 6029 }
6030 6030
6031 if (restart) { 6031 if (restart) {
6032 /* Kill timer */ 6032 /* Kill timer */
6033 priv->stop_hang_check = 1; 6033 priv->stop_hang_check = 1;
6034 priv->hangs++; 6034 priv->hangs++;
6035 6035
6036 /* Restart the NIC */ 6036 /* Restart the NIC */
6037 schedule_reset(priv); 6037 schedule_reset(priv);
6038 } 6038 }
6039 6039
6040 priv->last_rtc = rtc; 6040 priv->last_rtc = rtc;
6041 6041
6042 if (!priv->stop_hang_check) 6042 if (!priv->stop_hang_check)
6043 schedule_delayed_work(&priv->hang_check, HZ / 2); 6043 schedule_delayed_work(&priv->hang_check, HZ / 2);
6044 6044
6045 spin_unlock_irqrestore(&priv->low_lock, flags); 6045 spin_unlock_irqrestore(&priv->low_lock, flags);
6046 } 6046 }
6047 6047
6048 static void ipw2100_rf_kill(struct work_struct *work) 6048 static void ipw2100_rf_kill(struct work_struct *work)
6049 { 6049 {
6050 struct ipw2100_priv *priv = 6050 struct ipw2100_priv *priv =
6051 container_of(work, struct ipw2100_priv, rf_kill.work); 6051 container_of(work, struct ipw2100_priv, rf_kill.work);
6052 unsigned long flags; 6052 unsigned long flags;
6053 6053
6054 spin_lock_irqsave(&priv->low_lock, flags); 6054 spin_lock_irqsave(&priv->low_lock, flags);
6055 6055
6056 if (rf_kill_active(priv)) { 6056 if (rf_kill_active(priv)) {
6057 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n"); 6057 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
6058 if (!priv->stop_rf_kill) 6058 if (!priv->stop_rf_kill)
6059 schedule_delayed_work(&priv->rf_kill, 6059 schedule_delayed_work(&priv->rf_kill,
6060 round_jiffies_relative(HZ)); 6060 round_jiffies_relative(HZ));
6061 goto exit_unlock; 6061 goto exit_unlock;
6062 } 6062 }
6063 6063
6064 /* RF Kill is now disabled, so bring the device back up */ 6064 /* RF Kill is now disabled, so bring the device back up */
6065 6065
6066 if (!(priv->status & STATUS_RF_KILL_MASK)) { 6066 if (!(priv->status & STATUS_RF_KILL_MASK)) {
6067 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting " 6067 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
6068 "device\n"); 6068 "device\n");
6069 schedule_reset(priv); 6069 schedule_reset(priv);
6070 } else 6070 } else
6071 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still " 6071 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still "
6072 "enabled\n"); 6072 "enabled\n");
6073 6073
6074 exit_unlock: 6074 exit_unlock:
6075 spin_unlock_irqrestore(&priv->low_lock, flags); 6075 spin_unlock_irqrestore(&priv->low_lock, flags);
6076 } 6076 }
6077 6077
6078 static void ipw2100_irq_tasklet(struct ipw2100_priv *priv); 6078 static void ipw2100_irq_tasklet(struct ipw2100_priv *priv);
6079 6079
6080 static const struct net_device_ops ipw2100_netdev_ops = { 6080 static const struct net_device_ops ipw2100_netdev_ops = {
6081 .ndo_open = ipw2100_open, 6081 .ndo_open = ipw2100_open,
6082 .ndo_stop = ipw2100_close, 6082 .ndo_stop = ipw2100_close,
6083 .ndo_start_xmit = libipw_xmit, 6083 .ndo_start_xmit = libipw_xmit,
6084 .ndo_change_mtu = libipw_change_mtu, 6084 .ndo_change_mtu = libipw_change_mtu,
6085 .ndo_init = ipw2100_net_init, 6085 .ndo_init = ipw2100_net_init,
6086 .ndo_tx_timeout = ipw2100_tx_timeout, 6086 .ndo_tx_timeout = ipw2100_tx_timeout,
6087 .ndo_set_mac_address = ipw2100_set_address, 6087 .ndo_set_mac_address = ipw2100_set_address,
6088 .ndo_validate_addr = eth_validate_addr, 6088 .ndo_validate_addr = eth_validate_addr,
6089 }; 6089 };
6090 6090
6091 /* Look into using netdev destructor to shutdown libipw? */ 6091 /* Look into using netdev destructor to shutdown libipw? */
6092 6092
6093 static struct net_device *ipw2100_alloc_device(struct pci_dev *pci_dev, 6093 static struct net_device *ipw2100_alloc_device(struct pci_dev *pci_dev,
6094 void __iomem * base_addr, 6094 void __iomem * base_addr,
6095 unsigned long mem_start, 6095 unsigned long mem_start,
6096 unsigned long mem_len) 6096 unsigned long mem_len)
6097 { 6097 {
6098 struct ipw2100_priv *priv; 6098 struct ipw2100_priv *priv;
6099 struct net_device *dev; 6099 struct net_device *dev;
6100 6100
6101 dev = alloc_libipw(sizeof(struct ipw2100_priv), 0); 6101 dev = alloc_libipw(sizeof(struct ipw2100_priv), 0);
6102 if (!dev) 6102 if (!dev)
6103 return NULL; 6103 return NULL;
6104 priv = libipw_priv(dev); 6104 priv = libipw_priv(dev);
6105 priv->ieee = netdev_priv(dev); 6105 priv->ieee = netdev_priv(dev);
6106 priv->pci_dev = pci_dev; 6106 priv->pci_dev = pci_dev;
6107 priv->net_dev = dev; 6107 priv->net_dev = dev;
6108 6108
6109 priv->ieee->hard_start_xmit = ipw2100_tx; 6109 priv->ieee->hard_start_xmit = ipw2100_tx;
6110 priv->ieee->set_security = shim__set_security; 6110 priv->ieee->set_security = shim__set_security;
6111 6111
6112 priv->ieee->perfect_rssi = -20; 6112 priv->ieee->perfect_rssi = -20;
6113 priv->ieee->worst_rssi = -85; 6113 priv->ieee->worst_rssi = -85;
6114 6114
6115 dev->netdev_ops = &ipw2100_netdev_ops; 6115 dev->netdev_ops = &ipw2100_netdev_ops;
6116 dev->ethtool_ops = &ipw2100_ethtool_ops; 6116 dev->ethtool_ops = &ipw2100_ethtool_ops;
6117 dev->wireless_handlers = &ipw2100_wx_handler_def; 6117 dev->wireless_handlers = &ipw2100_wx_handler_def;
6118 priv->wireless_data.libipw = priv->ieee; 6118 priv->wireless_data.libipw = priv->ieee;
6119 dev->wireless_data = &priv->wireless_data; 6119 dev->wireless_data = &priv->wireless_data;
6120 dev->watchdog_timeo = 3 * HZ; 6120 dev->watchdog_timeo = 3 * HZ;
6121 dev->irq = 0; 6121 dev->irq = 0;
6122 6122
6123 dev->base_addr = (unsigned long)base_addr; 6123 dev->base_addr = (unsigned long)base_addr;
6124 dev->mem_start = mem_start; 6124 dev->mem_start = mem_start;
6125 dev->mem_end = dev->mem_start + mem_len - 1; 6125 dev->mem_end = dev->mem_start + mem_len - 1;
6126 6126
6127 /* NOTE: We don't use the wireless_handlers hook 6127 /* NOTE: We don't use the wireless_handlers hook
6128 * in dev as the system will start throwing WX requests 6128 * in dev as the system will start throwing WX requests
6129 * to us before we're actually initialized and it just 6129 * to us before we're actually initialized and it just
6130 * ends up causing problems. So, we just handle 6130 * ends up causing problems. So, we just handle
6131 * the WX extensions through the ipw2100_ioctl interface */ 6131 * the WX extensions through the ipw2100_ioctl interface */
6132 6132
6133 /* memset() puts everything to 0, so we only have explicitly set 6133 /* memset() puts everything to 0, so we only have explicitly set
6134 * those values that need to be something else */ 6134 * those values that need to be something else */
6135 6135
6136 /* If power management is turned on, default to AUTO mode */ 6136 /* If power management is turned on, default to AUTO mode */
6137 priv->power_mode = IPW_POWER_AUTO; 6137 priv->power_mode = IPW_POWER_AUTO;
6138 6138
6139 #ifdef CONFIG_IPW2100_MONITOR 6139 #ifdef CONFIG_IPW2100_MONITOR
6140 priv->config |= CFG_CRC_CHECK; 6140 priv->config |= CFG_CRC_CHECK;
6141 #endif 6141 #endif
6142 priv->ieee->wpa_enabled = 0; 6142 priv->ieee->wpa_enabled = 0;
6143 priv->ieee->drop_unencrypted = 0; 6143 priv->ieee->drop_unencrypted = 0;
6144 priv->ieee->privacy_invoked = 0; 6144 priv->ieee->privacy_invoked = 0;
6145 priv->ieee->ieee802_1x = 1; 6145 priv->ieee->ieee802_1x = 1;
6146 6146
6147 /* Set module parameters */ 6147 /* Set module parameters */
6148 switch (network_mode) { 6148 switch (network_mode) {
6149 case 1: 6149 case 1:
6150 priv->ieee->iw_mode = IW_MODE_ADHOC; 6150 priv->ieee->iw_mode = IW_MODE_ADHOC;
6151 break; 6151 break;
6152 #ifdef CONFIG_IPW2100_MONITOR 6152 #ifdef CONFIG_IPW2100_MONITOR
6153 case 2: 6153 case 2:
6154 priv->ieee->iw_mode = IW_MODE_MONITOR; 6154 priv->ieee->iw_mode = IW_MODE_MONITOR;
6155 break; 6155 break;
6156 #endif 6156 #endif
6157 default: 6157 default:
6158 case 0: 6158 case 0:
6159 priv->ieee->iw_mode = IW_MODE_INFRA; 6159 priv->ieee->iw_mode = IW_MODE_INFRA;
6160 break; 6160 break;
6161 } 6161 }
6162 6162
6163 if (disable == 1) 6163 if (disable == 1)
6164 priv->status |= STATUS_RF_KILL_SW; 6164 priv->status |= STATUS_RF_KILL_SW;
6165 6165
6166 if (channel != 0 && 6166 if (channel != 0 &&
6167 ((channel >= REG_MIN_CHANNEL) && (channel <= REG_MAX_CHANNEL))) { 6167 ((channel >= REG_MIN_CHANNEL) && (channel <= REG_MAX_CHANNEL))) {
6168 priv->config |= CFG_STATIC_CHANNEL; 6168 priv->config |= CFG_STATIC_CHANNEL;
6169 priv->channel = channel; 6169 priv->channel = channel;
6170 } 6170 }
6171 6171
6172 if (associate) 6172 if (associate)
6173 priv->config |= CFG_ASSOCIATE; 6173 priv->config |= CFG_ASSOCIATE;
6174 6174
6175 priv->beacon_interval = DEFAULT_BEACON_INTERVAL; 6175 priv->beacon_interval = DEFAULT_BEACON_INTERVAL;
6176 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT; 6176 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
6177 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT; 6177 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
6178 priv->rts_threshold = DEFAULT_RTS_THRESHOLD | RTS_DISABLED; 6178 priv->rts_threshold = DEFAULT_RTS_THRESHOLD | RTS_DISABLED;
6179 priv->frag_threshold = DEFAULT_FTS | FRAG_DISABLED; 6179 priv->frag_threshold = DEFAULT_FTS | FRAG_DISABLED;
6180 priv->tx_power = IPW_TX_POWER_DEFAULT; 6180 priv->tx_power = IPW_TX_POWER_DEFAULT;
6181 priv->tx_rates = DEFAULT_TX_RATES; 6181 priv->tx_rates = DEFAULT_TX_RATES;
6182 6182
6183 strcpy(priv->nick, "ipw2100"); 6183 strcpy(priv->nick, "ipw2100");
6184 6184
6185 spin_lock_init(&priv->low_lock); 6185 spin_lock_init(&priv->low_lock);
6186 mutex_init(&priv->action_mutex); 6186 mutex_init(&priv->action_mutex);
6187 mutex_init(&priv->adapter_mutex); 6187 mutex_init(&priv->adapter_mutex);
6188 6188
6189 init_waitqueue_head(&priv->wait_command_queue); 6189 init_waitqueue_head(&priv->wait_command_queue);
6190 6190
6191 netif_carrier_off(dev); 6191 netif_carrier_off(dev);
6192 6192
6193 INIT_LIST_HEAD(&priv->msg_free_list); 6193 INIT_LIST_HEAD(&priv->msg_free_list);
6194 INIT_LIST_HEAD(&priv->msg_pend_list); 6194 INIT_LIST_HEAD(&priv->msg_pend_list);
6195 INIT_STAT(&priv->msg_free_stat); 6195 INIT_STAT(&priv->msg_free_stat);
6196 INIT_STAT(&priv->msg_pend_stat); 6196 INIT_STAT(&priv->msg_pend_stat);
6197 6197
6198 INIT_LIST_HEAD(&priv->tx_free_list); 6198 INIT_LIST_HEAD(&priv->tx_free_list);
6199 INIT_LIST_HEAD(&priv->tx_pend_list); 6199 INIT_LIST_HEAD(&priv->tx_pend_list);
6200 INIT_STAT(&priv->tx_free_stat); 6200 INIT_STAT(&priv->tx_free_stat);
6201 INIT_STAT(&priv->tx_pend_stat); 6201 INIT_STAT(&priv->tx_pend_stat);
6202 6202
6203 INIT_LIST_HEAD(&priv->fw_pend_list); 6203 INIT_LIST_HEAD(&priv->fw_pend_list);
6204 INIT_STAT(&priv->fw_pend_stat); 6204 INIT_STAT(&priv->fw_pend_stat);
6205 6205
6206 INIT_DELAYED_WORK(&priv->reset_work, ipw2100_reset_adapter); 6206 INIT_DELAYED_WORK(&priv->reset_work, ipw2100_reset_adapter);
6207 INIT_DELAYED_WORK(&priv->security_work, ipw2100_security_work); 6207 INIT_DELAYED_WORK(&priv->security_work, ipw2100_security_work);
6208 INIT_DELAYED_WORK(&priv->wx_event_work, ipw2100_wx_event_work); 6208 INIT_DELAYED_WORK(&priv->wx_event_work, ipw2100_wx_event_work);
6209 INIT_DELAYED_WORK(&priv->hang_check, ipw2100_hang_check); 6209 INIT_DELAYED_WORK(&priv->hang_check, ipw2100_hang_check);
6210 INIT_DELAYED_WORK(&priv->rf_kill, ipw2100_rf_kill); 6210 INIT_DELAYED_WORK(&priv->rf_kill, ipw2100_rf_kill);
6211 INIT_WORK(&priv->scan_event_now, ipw2100_scan_event_now); 6211 INIT_WORK(&priv->scan_event_now, ipw2100_scan_event_now);
6212 INIT_DELAYED_WORK(&priv->scan_event_later, ipw2100_scan_event_later); 6212 INIT_DELAYED_WORK(&priv->scan_event_later, ipw2100_scan_event_later);
6213 6213
6214 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long)) 6214 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
6215 ipw2100_irq_tasklet, (unsigned long)priv); 6215 ipw2100_irq_tasklet, (unsigned long)priv);
6216 6216
6217 /* NOTE: We do not start the deferred work for status checks yet */ 6217 /* NOTE: We do not start the deferred work for status checks yet */
6218 priv->stop_rf_kill = 1; 6218 priv->stop_rf_kill = 1;
6219 priv->stop_hang_check = 1; 6219 priv->stop_hang_check = 1;
6220 6220
6221 return dev; 6221 return dev;
6222 } 6222 }
6223 6223
6224 static int ipw2100_pci_init_one(struct pci_dev *pci_dev, 6224 static int ipw2100_pci_init_one(struct pci_dev *pci_dev,
6225 const struct pci_device_id *ent) 6225 const struct pci_device_id *ent)
6226 { 6226 {
6227 unsigned long mem_start, mem_len, mem_flags; 6227 unsigned long mem_start, mem_len, mem_flags;
6228 void __iomem *base_addr = NULL; 6228 void __iomem *base_addr = NULL;
6229 struct net_device *dev = NULL; 6229 struct net_device *dev = NULL;
6230 struct ipw2100_priv *priv = NULL; 6230 struct ipw2100_priv *priv = NULL;
6231 int err = 0; 6231 int err = 0;
6232 int registered = 0; 6232 int registered = 0;
6233 u32 val; 6233 u32 val;
6234 6234
6235 IPW_DEBUG_INFO("enter\n"); 6235 IPW_DEBUG_INFO("enter\n");
6236 6236
6237 mem_start = pci_resource_start(pci_dev, 0); 6237 mem_start = pci_resource_start(pci_dev, 0);
6238 mem_len = pci_resource_len(pci_dev, 0); 6238 mem_len = pci_resource_len(pci_dev, 0);
6239 mem_flags = pci_resource_flags(pci_dev, 0); 6239 mem_flags = pci_resource_flags(pci_dev, 0);
6240 6240
6241 if ((mem_flags & IORESOURCE_MEM) != IORESOURCE_MEM) { 6241 if ((mem_flags & IORESOURCE_MEM) != IORESOURCE_MEM) {
6242 IPW_DEBUG_INFO("weird - resource type is not memory\n"); 6242 IPW_DEBUG_INFO("weird - resource type is not memory\n");
6243 err = -ENODEV; 6243 err = -ENODEV;
6244 goto fail; 6244 goto fail;
6245 } 6245 }
6246 6246
6247 base_addr = ioremap_nocache(mem_start, mem_len); 6247 base_addr = ioremap_nocache(mem_start, mem_len);
6248 if (!base_addr) { 6248 if (!base_addr) {
6249 printk(KERN_WARNING DRV_NAME 6249 printk(KERN_WARNING DRV_NAME
6250 "Error calling ioremap_nocache.\n"); 6250 "Error calling ioremap_nocache.\n");
6251 err = -EIO; 6251 err = -EIO;
6252 goto fail; 6252 goto fail;
6253 } 6253 }
6254 6254
6255 /* allocate and initialize our net_device */ 6255 /* allocate and initialize our net_device */
6256 dev = ipw2100_alloc_device(pci_dev, base_addr, mem_start, mem_len); 6256 dev = ipw2100_alloc_device(pci_dev, base_addr, mem_start, mem_len);
6257 if (!dev) { 6257 if (!dev) {
6258 printk(KERN_WARNING DRV_NAME 6258 printk(KERN_WARNING DRV_NAME
6259 "Error calling ipw2100_alloc_device.\n"); 6259 "Error calling ipw2100_alloc_device.\n");
6260 err = -ENOMEM; 6260 err = -ENOMEM;
6261 goto fail; 6261 goto fail;
6262 } 6262 }
6263 6263
6264 /* set up PCI mappings for device */ 6264 /* set up PCI mappings for device */
6265 err = pci_enable_device(pci_dev); 6265 err = pci_enable_device(pci_dev);
6266 if (err) { 6266 if (err) {
6267 printk(KERN_WARNING DRV_NAME 6267 printk(KERN_WARNING DRV_NAME
6268 "Error calling pci_enable_device.\n"); 6268 "Error calling pci_enable_device.\n");
6269 return err; 6269 return err;
6270 } 6270 }
6271 6271
6272 priv = libipw_priv(dev); 6272 priv = libipw_priv(dev);
6273 6273
6274 pci_set_master(pci_dev); 6274 pci_set_master(pci_dev);
6275 pci_set_drvdata(pci_dev, priv); 6275 pci_set_drvdata(pci_dev, priv);
6276 6276
6277 err = pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32)); 6277 err = pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32));
6278 if (err) { 6278 if (err) {
6279 printk(KERN_WARNING DRV_NAME 6279 printk(KERN_WARNING DRV_NAME
6280 "Error calling pci_set_dma_mask.\n"); 6280 "Error calling pci_set_dma_mask.\n");
6281 pci_disable_device(pci_dev); 6281 pci_disable_device(pci_dev);
6282 return err; 6282 return err;
6283 } 6283 }
6284 6284
6285 err = pci_request_regions(pci_dev, DRV_NAME); 6285 err = pci_request_regions(pci_dev, DRV_NAME);
6286 if (err) { 6286 if (err) {
6287 printk(KERN_WARNING DRV_NAME 6287 printk(KERN_WARNING DRV_NAME
6288 "Error calling pci_request_regions.\n"); 6288 "Error calling pci_request_regions.\n");
6289 pci_disable_device(pci_dev); 6289 pci_disable_device(pci_dev);
6290 return err; 6290 return err;
6291 } 6291 }
6292 6292
6293 /* We disable the RETRY_TIMEOUT register (0x41) to keep 6293 /* We disable the RETRY_TIMEOUT register (0x41) to keep
6294 * PCI Tx retries from interfering with C3 CPU state */ 6294 * PCI Tx retries from interfering with C3 CPU state */
6295 pci_read_config_dword(pci_dev, 0x40, &val); 6295 pci_read_config_dword(pci_dev, 0x40, &val);
6296 if ((val & 0x0000ff00) != 0) 6296 if ((val & 0x0000ff00) != 0)
6297 pci_write_config_dword(pci_dev, 0x40, val & 0xffff00ff); 6297 pci_write_config_dword(pci_dev, 0x40, val & 0xffff00ff);
6298 6298
6299 pci_set_power_state(pci_dev, PCI_D0); 6299 pci_set_power_state(pci_dev, PCI_D0);
6300 6300
6301 if (!ipw2100_hw_is_adapter_in_system(dev)) { 6301 if (!ipw2100_hw_is_adapter_in_system(dev)) {
6302 printk(KERN_WARNING DRV_NAME 6302 printk(KERN_WARNING DRV_NAME
6303 "Device not found via register read.\n"); 6303 "Device not found via register read.\n");
6304 err = -ENODEV; 6304 err = -ENODEV;
6305 goto fail; 6305 goto fail;
6306 } 6306 }
6307 6307
6308 SET_NETDEV_DEV(dev, &pci_dev->dev); 6308 SET_NETDEV_DEV(dev, &pci_dev->dev);
6309 6309
6310 /* Force interrupts to be shut off on the device */ 6310 /* Force interrupts to be shut off on the device */
6311 priv->status |= STATUS_INT_ENABLED; 6311 priv->status |= STATUS_INT_ENABLED;
6312 ipw2100_disable_interrupts(priv); 6312 ipw2100_disable_interrupts(priv);
6313 6313
6314 /* Allocate and initialize the Tx/Rx queues and lists */ 6314 /* Allocate and initialize the Tx/Rx queues and lists */
6315 if (ipw2100_queues_allocate(priv)) { 6315 if (ipw2100_queues_allocate(priv)) {
6316 printk(KERN_WARNING DRV_NAME 6316 printk(KERN_WARNING DRV_NAME
6317 "Error calling ipw2100_queues_allocate.\n"); 6317 "Error calling ipw2100_queues_allocate.\n");
6318 err = -ENOMEM; 6318 err = -ENOMEM;
6319 goto fail; 6319 goto fail;
6320 } 6320 }
6321 ipw2100_queues_initialize(priv); 6321 ipw2100_queues_initialize(priv);
6322 6322
6323 err = request_irq(pci_dev->irq, 6323 err = request_irq(pci_dev->irq,
6324 ipw2100_interrupt, IRQF_SHARED, dev->name, priv); 6324 ipw2100_interrupt, IRQF_SHARED, dev->name, priv);
6325 if (err) { 6325 if (err) {
6326 printk(KERN_WARNING DRV_NAME 6326 printk(KERN_WARNING DRV_NAME
6327 "Error calling request_irq: %d.\n", pci_dev->irq); 6327 "Error calling request_irq: %d.\n", pci_dev->irq);
6328 goto fail; 6328 goto fail;
6329 } 6329 }
6330 dev->irq = pci_dev->irq; 6330 dev->irq = pci_dev->irq;
6331 6331
6332 IPW_DEBUG_INFO("Attempting to register device...\n"); 6332 IPW_DEBUG_INFO("Attempting to register device...\n");
6333 6333
6334 printk(KERN_INFO DRV_NAME 6334 printk(KERN_INFO DRV_NAME
6335 ": Detected Intel PRO/Wireless 2100 Network Connection\n"); 6335 ": Detected Intel PRO/Wireless 2100 Network Connection\n");
6336 6336
6337 /* Bring up the interface. Pre 0.46, after we registered the 6337 /* Bring up the interface. Pre 0.46, after we registered the
6338 * network device we would call ipw2100_up. This introduced a race 6338 * network device we would call ipw2100_up. This introduced a race
6339 * condition with newer hotplug configurations (network was coming 6339 * condition with newer hotplug configurations (network was coming
6340 * up and making calls before the device was initialized). 6340 * up and making calls before the device was initialized).
6341 * 6341 *
6342 * If we called ipw2100_up before we registered the device, then the 6342 * If we called ipw2100_up before we registered the device, then the
6343 * device name wasn't registered. So, we instead use the net_dev->init 6343 * device name wasn't registered. So, we instead use the net_dev->init
6344 * member to call a function that then just turns and calls ipw2100_up. 6344 * member to call a function that then just turns and calls ipw2100_up.
6345 * net_dev->init is called after name allocation but before the 6345 * net_dev->init is called after name allocation but before the
6346 * notifier chain is called */ 6346 * notifier chain is called */
6347 err = register_netdev(dev); 6347 err = register_netdev(dev);
6348 if (err) { 6348 if (err) {
6349 printk(KERN_WARNING DRV_NAME 6349 printk(KERN_WARNING DRV_NAME
6350 "Error calling register_netdev.\n"); 6350 "Error calling register_netdev.\n");
6351 goto fail; 6351 goto fail;
6352 } 6352 }
6353 6353
6354 mutex_lock(&priv->action_mutex); 6354 mutex_lock(&priv->action_mutex);
6355 registered = 1; 6355 registered = 1;
6356 6356
6357 IPW_DEBUG_INFO("%s: Bound to %s\n", dev->name, pci_name(pci_dev)); 6357 IPW_DEBUG_INFO("%s: Bound to %s\n", dev->name, pci_name(pci_dev));
6358 6358
6359 /* perform this after register_netdev so that dev->name is set */ 6359 /* perform this after register_netdev so that dev->name is set */
6360 err = sysfs_create_group(&pci_dev->dev.kobj, &ipw2100_attribute_group); 6360 err = sysfs_create_group(&pci_dev->dev.kobj, &ipw2100_attribute_group);
6361 if (err) 6361 if (err)
6362 goto fail_unlock; 6362 goto fail_unlock;
6363 6363
6364 /* If the RF Kill switch is disabled, go ahead and complete the 6364 /* If the RF Kill switch is disabled, go ahead and complete the
6365 * startup sequence */ 6365 * startup sequence */
6366 if (!(priv->status & STATUS_RF_KILL_MASK)) { 6366 if (!(priv->status & STATUS_RF_KILL_MASK)) {
6367 /* Enable the adapter - sends HOST_COMPLETE */ 6367 /* Enable the adapter - sends HOST_COMPLETE */
6368 if (ipw2100_enable_adapter(priv)) { 6368 if (ipw2100_enable_adapter(priv)) {
6369 printk(KERN_WARNING DRV_NAME 6369 printk(KERN_WARNING DRV_NAME
6370 ": %s: failed in call to enable adapter.\n", 6370 ": %s: failed in call to enable adapter.\n",
6371 priv->net_dev->name); 6371 priv->net_dev->name);
6372 ipw2100_hw_stop_adapter(priv); 6372 ipw2100_hw_stop_adapter(priv);
6373 err = -EIO; 6373 err = -EIO;
6374 goto fail_unlock; 6374 goto fail_unlock;
6375 } 6375 }
6376 6376
6377 /* Start a scan . . . */ 6377 /* Start a scan . . . */
6378 ipw2100_set_scan_options(priv); 6378 ipw2100_set_scan_options(priv);
6379 ipw2100_start_scan(priv); 6379 ipw2100_start_scan(priv);
6380 } 6380 }
6381 6381
6382 IPW_DEBUG_INFO("exit\n"); 6382 IPW_DEBUG_INFO("exit\n");
6383 6383
6384 priv->status |= STATUS_INITIALIZED; 6384 priv->status |= STATUS_INITIALIZED;
6385 6385
6386 mutex_unlock(&priv->action_mutex); 6386 mutex_unlock(&priv->action_mutex);
6387 6387
6388 return 0; 6388 return 0;
6389 6389
6390 fail_unlock: 6390 fail_unlock:
6391 mutex_unlock(&priv->action_mutex); 6391 mutex_unlock(&priv->action_mutex);
6392 6392
6393 fail: 6393 fail:
6394 if (dev) { 6394 if (dev) {
6395 if (registered) 6395 if (registered)
6396 unregister_netdev(dev); 6396 unregister_netdev(dev);
6397 6397
6398 ipw2100_hw_stop_adapter(priv); 6398 ipw2100_hw_stop_adapter(priv);
6399 6399
6400 ipw2100_disable_interrupts(priv); 6400 ipw2100_disable_interrupts(priv);
6401 6401
6402 if (dev->irq) 6402 if (dev->irq)
6403 free_irq(dev->irq, priv); 6403 free_irq(dev->irq, priv);
6404 6404
6405 ipw2100_kill_works(priv); 6405 ipw2100_kill_works(priv);
6406 6406
6407 /* These are safe to call even if they weren't allocated */ 6407 /* These are safe to call even if they weren't allocated */
6408 ipw2100_queues_free(priv); 6408 ipw2100_queues_free(priv);
6409 sysfs_remove_group(&pci_dev->dev.kobj, 6409 sysfs_remove_group(&pci_dev->dev.kobj,
6410 &ipw2100_attribute_group); 6410 &ipw2100_attribute_group);
6411 6411
6412 free_libipw(dev, 0); 6412 free_libipw(dev, 0);
6413 pci_set_drvdata(pci_dev, NULL); 6413 pci_set_drvdata(pci_dev, NULL);
6414 } 6414 }
6415 6415
6416 if (base_addr) 6416 if (base_addr)
6417 iounmap(base_addr); 6417 iounmap(base_addr);
6418 6418
6419 pci_release_regions(pci_dev); 6419 pci_release_regions(pci_dev);
6420 pci_disable_device(pci_dev); 6420 pci_disable_device(pci_dev);
6421 6421
6422 return err; 6422 return err;
6423 } 6423 }
6424 6424
6425 static void __devexit ipw2100_pci_remove_one(struct pci_dev *pci_dev) 6425 static void __devexit ipw2100_pci_remove_one(struct pci_dev *pci_dev)
6426 { 6426 {
6427 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev); 6427 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev);
6428 struct net_device *dev; 6428 struct net_device *dev;
6429 6429
6430 if (priv) { 6430 if (priv) {
6431 mutex_lock(&priv->action_mutex); 6431 mutex_lock(&priv->action_mutex);
6432 6432
6433 priv->status &= ~STATUS_INITIALIZED; 6433 priv->status &= ~STATUS_INITIALIZED;
6434 6434
6435 dev = priv->net_dev; 6435 dev = priv->net_dev;
6436 sysfs_remove_group(&pci_dev->dev.kobj, 6436 sysfs_remove_group(&pci_dev->dev.kobj,
6437 &ipw2100_attribute_group); 6437 &ipw2100_attribute_group);
6438 6438
6439 #ifdef CONFIG_PM 6439 #ifdef CONFIG_PM
6440 if (ipw2100_firmware.version) 6440 if (ipw2100_firmware.version)
6441 ipw2100_release_firmware(priv, &ipw2100_firmware); 6441 ipw2100_release_firmware(priv, &ipw2100_firmware);
6442 #endif 6442 #endif
6443 /* Take down the hardware */ 6443 /* Take down the hardware */
6444 ipw2100_down(priv); 6444 ipw2100_down(priv);
6445 6445
6446 /* Release the mutex so that the network subsystem can 6446 /* Release the mutex so that the network subsystem can
6447 * complete any needed calls into the driver... */ 6447 * complete any needed calls into the driver... */
6448 mutex_unlock(&priv->action_mutex); 6448 mutex_unlock(&priv->action_mutex);
6449 6449
6450 /* Unregister the device first - this results in close() 6450 /* Unregister the device first - this results in close()
6451 * being called if the device is open. If we free storage 6451 * being called if the device is open. If we free storage
6452 * first, then close() will crash. */ 6452 * first, then close() will crash. */
6453 unregister_netdev(dev); 6453 unregister_netdev(dev);
6454 6454
6455 ipw2100_kill_works(priv); 6455 ipw2100_kill_works(priv);
6456 6456
6457 ipw2100_queues_free(priv); 6457 ipw2100_queues_free(priv);
6458 6458
6459 /* Free potential debugging firmware snapshot */ 6459 /* Free potential debugging firmware snapshot */
6460 ipw2100_snapshot_free(priv); 6460 ipw2100_snapshot_free(priv);
6461 6461
6462 if (dev->irq) 6462 if (dev->irq)
6463 free_irq(dev->irq, priv); 6463 free_irq(dev->irq, priv);
6464 6464
6465 if (dev->base_addr) 6465 if (dev->base_addr)
6466 iounmap((void __iomem *)dev->base_addr); 6466 iounmap((void __iomem *)dev->base_addr);
6467 6467
6468 /* wiphy_unregister needs to be here, before free_libipw */ 6468 /* wiphy_unregister needs to be here, before free_libipw */
6469 wiphy_unregister(priv->ieee->wdev.wiphy); 6469 wiphy_unregister(priv->ieee->wdev.wiphy);
6470 kfree(priv->ieee->bg_band.channels); 6470 kfree(priv->ieee->bg_band.channels);
6471 free_libipw(dev, 0); 6471 free_libipw(dev, 0);
6472 } 6472 }
6473 6473
6474 pci_release_regions(pci_dev); 6474 pci_release_regions(pci_dev);
6475 pci_disable_device(pci_dev); 6475 pci_disable_device(pci_dev);
6476 6476
6477 IPW_DEBUG_INFO("exit\n"); 6477 IPW_DEBUG_INFO("exit\n");
6478 } 6478 }
6479 6479
6480 #ifdef CONFIG_PM 6480 #ifdef CONFIG_PM
6481 static int ipw2100_suspend(struct pci_dev *pci_dev, pm_message_t state) 6481 static int ipw2100_suspend(struct pci_dev *pci_dev, pm_message_t state)
6482 { 6482 {
6483 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev); 6483 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev);
6484 struct net_device *dev = priv->net_dev; 6484 struct net_device *dev = priv->net_dev;
6485 6485
6486 IPW_DEBUG_INFO("%s: Going into suspend...\n", dev->name); 6486 IPW_DEBUG_INFO("%s: Going into suspend...\n", dev->name);
6487 6487
6488 mutex_lock(&priv->action_mutex); 6488 mutex_lock(&priv->action_mutex);
6489 if (priv->status & STATUS_INITIALIZED) { 6489 if (priv->status & STATUS_INITIALIZED) {
6490 /* Take down the device; powers it off, etc. */ 6490 /* Take down the device; powers it off, etc. */
6491 ipw2100_down(priv); 6491 ipw2100_down(priv);
6492 } 6492 }
6493 6493
6494 /* Remove the PRESENT state of the device */ 6494 /* Remove the PRESENT state of the device */
6495 netif_device_detach(dev); 6495 netif_device_detach(dev);
6496 6496
6497 pci_save_state(pci_dev); 6497 pci_save_state(pci_dev);
6498 pci_disable_device(pci_dev); 6498 pci_disable_device(pci_dev);
6499 pci_set_power_state(pci_dev, PCI_D3hot); 6499 pci_set_power_state(pci_dev, PCI_D3hot);
6500 6500
6501 priv->suspend_at = get_seconds(); 6501 priv->suspend_at = get_seconds();
6502 6502
6503 mutex_unlock(&priv->action_mutex); 6503 mutex_unlock(&priv->action_mutex);
6504 6504
6505 return 0; 6505 return 0;
6506 } 6506 }
6507 6507
6508 static int ipw2100_resume(struct pci_dev *pci_dev) 6508 static int ipw2100_resume(struct pci_dev *pci_dev)
6509 { 6509 {
6510 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev); 6510 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev);
6511 struct net_device *dev = priv->net_dev; 6511 struct net_device *dev = priv->net_dev;
6512 int err; 6512 int err;
6513 u32 val; 6513 u32 val;
6514 6514
6515 if (IPW2100_PM_DISABLED) 6515 if (IPW2100_PM_DISABLED)
6516 return 0; 6516 return 0;
6517 6517
6518 mutex_lock(&priv->action_mutex); 6518 mutex_lock(&priv->action_mutex);
6519 6519
6520 IPW_DEBUG_INFO("%s: Coming out of suspend...\n", dev->name); 6520 IPW_DEBUG_INFO("%s: Coming out of suspend...\n", dev->name);
6521 6521
6522 pci_set_power_state(pci_dev, PCI_D0); 6522 pci_set_power_state(pci_dev, PCI_D0);
6523 err = pci_enable_device(pci_dev); 6523 err = pci_enable_device(pci_dev);
6524 if (err) { 6524 if (err) {
6525 printk(KERN_ERR "%s: pci_enable_device failed on resume\n", 6525 printk(KERN_ERR "%s: pci_enable_device failed on resume\n",
6526 dev->name); 6526 dev->name);
6527 mutex_unlock(&priv->action_mutex); 6527 mutex_unlock(&priv->action_mutex);
6528 return err; 6528 return err;
6529 } 6529 }
6530 pci_restore_state(pci_dev); 6530 pci_restore_state(pci_dev);
6531 6531
6532 /* 6532 /*
6533 * Suspend/Resume resets the PCI configuration space, so we have to 6533 * Suspend/Resume resets the PCI configuration space, so we have to
6534 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries 6534 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
6535 * from interfering with C3 CPU state. pci_restore_state won't help 6535 * from interfering with C3 CPU state. pci_restore_state won't help
6536 * here since it only restores the first 64 bytes pci config header. 6536 * here since it only restores the first 64 bytes pci config header.
6537 */ 6537 */
6538 pci_read_config_dword(pci_dev, 0x40, &val); 6538 pci_read_config_dword(pci_dev, 0x40, &val);
6539 if ((val & 0x0000ff00) != 0) 6539 if ((val & 0x0000ff00) != 0)
6540 pci_write_config_dword(pci_dev, 0x40, val & 0xffff00ff); 6540 pci_write_config_dword(pci_dev, 0x40, val & 0xffff00ff);
6541 6541
6542 /* Set the device back into the PRESENT state; this will also wake 6542 /* Set the device back into the PRESENT state; this will also wake
6543 * the queue of needed */ 6543 * the queue of needed */
6544 netif_device_attach(dev); 6544 netif_device_attach(dev);
6545 6545
6546 priv->suspend_time = get_seconds() - priv->suspend_at; 6546 priv->suspend_time = get_seconds() - priv->suspend_at;
6547 6547
6548 /* Bring the device back up */ 6548 /* Bring the device back up */
6549 if (!(priv->status & STATUS_RF_KILL_SW)) 6549 if (!(priv->status & STATUS_RF_KILL_SW))
6550 ipw2100_up(priv, 0); 6550 ipw2100_up(priv, 0);
6551 6551
6552 mutex_unlock(&priv->action_mutex); 6552 mutex_unlock(&priv->action_mutex);
6553 6553
6554 return 0; 6554 return 0;
6555 } 6555 }
6556 #endif 6556 #endif
6557 6557
6558 static void ipw2100_shutdown(struct pci_dev *pci_dev) 6558 static void ipw2100_shutdown(struct pci_dev *pci_dev)
6559 { 6559 {
6560 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev); 6560 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev);
6561 6561
6562 /* Take down the device; powers it off, etc. */ 6562 /* Take down the device; powers it off, etc. */
6563 ipw2100_down(priv); 6563 ipw2100_down(priv);
6564 6564
6565 pci_disable_device(pci_dev); 6565 pci_disable_device(pci_dev);
6566 } 6566 }
6567 6567
6568 #define IPW2100_DEV_ID(x) { PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, x } 6568 #define IPW2100_DEV_ID(x) { PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, x }
6569 6569
6570 static DEFINE_PCI_DEVICE_TABLE(ipw2100_pci_id_table) = { 6570 static DEFINE_PCI_DEVICE_TABLE(ipw2100_pci_id_table) = {
6571 IPW2100_DEV_ID(0x2520), /* IN 2100A mPCI 3A */ 6571 IPW2100_DEV_ID(0x2520), /* IN 2100A mPCI 3A */
6572 IPW2100_DEV_ID(0x2521), /* IN 2100A mPCI 3B */ 6572 IPW2100_DEV_ID(0x2521), /* IN 2100A mPCI 3B */
6573 IPW2100_DEV_ID(0x2524), /* IN 2100A mPCI 3B */ 6573 IPW2100_DEV_ID(0x2524), /* IN 2100A mPCI 3B */
6574 IPW2100_DEV_ID(0x2525), /* IN 2100A mPCI 3B */ 6574 IPW2100_DEV_ID(0x2525), /* IN 2100A mPCI 3B */
6575 IPW2100_DEV_ID(0x2526), /* IN 2100A mPCI Gen A3 */ 6575 IPW2100_DEV_ID(0x2526), /* IN 2100A mPCI Gen A3 */
6576 IPW2100_DEV_ID(0x2522), /* IN 2100 mPCI 3B */ 6576 IPW2100_DEV_ID(0x2522), /* IN 2100 mPCI 3B */
6577 IPW2100_DEV_ID(0x2523), /* IN 2100 mPCI 3A */ 6577 IPW2100_DEV_ID(0x2523), /* IN 2100 mPCI 3A */
6578 IPW2100_DEV_ID(0x2527), /* IN 2100 mPCI 3B */ 6578 IPW2100_DEV_ID(0x2527), /* IN 2100 mPCI 3B */
6579 IPW2100_DEV_ID(0x2528), /* IN 2100 mPCI 3B */ 6579 IPW2100_DEV_ID(0x2528), /* IN 2100 mPCI 3B */
6580 IPW2100_DEV_ID(0x2529), /* IN 2100 mPCI 3B */ 6580 IPW2100_DEV_ID(0x2529), /* IN 2100 mPCI 3B */
6581 IPW2100_DEV_ID(0x252B), /* IN 2100 mPCI 3A */ 6581 IPW2100_DEV_ID(0x252B), /* IN 2100 mPCI 3A */
6582 IPW2100_DEV_ID(0x252C), /* IN 2100 mPCI 3A */ 6582 IPW2100_DEV_ID(0x252C), /* IN 2100 mPCI 3A */
6583 IPW2100_DEV_ID(0x252D), /* IN 2100 mPCI 3A */ 6583 IPW2100_DEV_ID(0x252D), /* IN 2100 mPCI 3A */
6584 6584
6585 IPW2100_DEV_ID(0x2550), /* IB 2100A mPCI 3B */ 6585 IPW2100_DEV_ID(0x2550), /* IB 2100A mPCI 3B */
6586 IPW2100_DEV_ID(0x2551), /* IB 2100 mPCI 3B */ 6586 IPW2100_DEV_ID(0x2551), /* IB 2100 mPCI 3B */
6587 IPW2100_DEV_ID(0x2553), /* IB 2100 mPCI 3B */ 6587 IPW2100_DEV_ID(0x2553), /* IB 2100 mPCI 3B */
6588 IPW2100_DEV_ID(0x2554), /* IB 2100 mPCI 3B */ 6588 IPW2100_DEV_ID(0x2554), /* IB 2100 mPCI 3B */
6589 IPW2100_DEV_ID(0x2555), /* IB 2100 mPCI 3B */ 6589 IPW2100_DEV_ID(0x2555), /* IB 2100 mPCI 3B */
6590 6590
6591 IPW2100_DEV_ID(0x2560), /* DE 2100A mPCI 3A */ 6591 IPW2100_DEV_ID(0x2560), /* DE 2100A mPCI 3A */
6592 IPW2100_DEV_ID(0x2562), /* DE 2100A mPCI 3A */ 6592 IPW2100_DEV_ID(0x2562), /* DE 2100A mPCI 3A */
6593 IPW2100_DEV_ID(0x2563), /* DE 2100A mPCI 3A */ 6593 IPW2100_DEV_ID(0x2563), /* DE 2100A mPCI 3A */
6594 IPW2100_DEV_ID(0x2561), /* DE 2100 mPCI 3A */ 6594 IPW2100_DEV_ID(0x2561), /* DE 2100 mPCI 3A */
6595 IPW2100_DEV_ID(0x2565), /* DE 2100 mPCI 3A */ 6595 IPW2100_DEV_ID(0x2565), /* DE 2100 mPCI 3A */
6596 IPW2100_DEV_ID(0x2566), /* DE 2100 mPCI 3A */ 6596 IPW2100_DEV_ID(0x2566), /* DE 2100 mPCI 3A */
6597 IPW2100_DEV_ID(0x2567), /* DE 2100 mPCI 3A */ 6597 IPW2100_DEV_ID(0x2567), /* DE 2100 mPCI 3A */
6598 6598
6599 IPW2100_DEV_ID(0x2570), /* GA 2100 mPCI 3B */ 6599 IPW2100_DEV_ID(0x2570), /* GA 2100 mPCI 3B */
6600 6600
6601 IPW2100_DEV_ID(0x2580), /* TO 2100A mPCI 3B */ 6601 IPW2100_DEV_ID(0x2580), /* TO 2100A mPCI 3B */
6602 IPW2100_DEV_ID(0x2582), /* TO 2100A mPCI 3B */ 6602 IPW2100_DEV_ID(0x2582), /* TO 2100A mPCI 3B */
6603 IPW2100_DEV_ID(0x2583), /* TO 2100A mPCI 3B */ 6603 IPW2100_DEV_ID(0x2583), /* TO 2100A mPCI 3B */
6604 IPW2100_DEV_ID(0x2581), /* TO 2100 mPCI 3B */ 6604 IPW2100_DEV_ID(0x2581), /* TO 2100 mPCI 3B */
6605 IPW2100_DEV_ID(0x2585), /* TO 2100 mPCI 3B */ 6605 IPW2100_DEV_ID(0x2585), /* TO 2100 mPCI 3B */
6606 IPW2100_DEV_ID(0x2586), /* TO 2100 mPCI 3B */ 6606 IPW2100_DEV_ID(0x2586), /* TO 2100 mPCI 3B */
6607 IPW2100_DEV_ID(0x2587), /* TO 2100 mPCI 3B */ 6607 IPW2100_DEV_ID(0x2587), /* TO 2100 mPCI 3B */
6608 6608
6609 IPW2100_DEV_ID(0x2590), /* SO 2100A mPCI 3B */ 6609 IPW2100_DEV_ID(0x2590), /* SO 2100A mPCI 3B */
6610 IPW2100_DEV_ID(0x2592), /* SO 2100A mPCI 3B */ 6610 IPW2100_DEV_ID(0x2592), /* SO 2100A mPCI 3B */
6611 IPW2100_DEV_ID(0x2591), /* SO 2100 mPCI 3B */ 6611 IPW2100_DEV_ID(0x2591), /* SO 2100 mPCI 3B */
6612 IPW2100_DEV_ID(0x2593), /* SO 2100 mPCI 3B */ 6612 IPW2100_DEV_ID(0x2593), /* SO 2100 mPCI 3B */
6613 IPW2100_DEV_ID(0x2596), /* SO 2100 mPCI 3B */ 6613 IPW2100_DEV_ID(0x2596), /* SO 2100 mPCI 3B */
6614 IPW2100_DEV_ID(0x2598), /* SO 2100 mPCI 3B */ 6614 IPW2100_DEV_ID(0x2598), /* SO 2100 mPCI 3B */
6615 6615
6616 IPW2100_DEV_ID(0x25A0), /* HP 2100 mPCI 3B */ 6616 IPW2100_DEV_ID(0x25A0), /* HP 2100 mPCI 3B */
6617 {0,}, 6617 {0,},
6618 }; 6618 };
6619 6619
6620 MODULE_DEVICE_TABLE(pci, ipw2100_pci_id_table); 6620 MODULE_DEVICE_TABLE(pci, ipw2100_pci_id_table);
6621 6621
6622 static struct pci_driver ipw2100_pci_driver = { 6622 static struct pci_driver ipw2100_pci_driver = {
6623 .name = DRV_NAME, 6623 .name = DRV_NAME,
6624 .id_table = ipw2100_pci_id_table, 6624 .id_table = ipw2100_pci_id_table,
6625 .probe = ipw2100_pci_init_one, 6625 .probe = ipw2100_pci_init_one,
6626 .remove = __devexit_p(ipw2100_pci_remove_one), 6626 .remove = __devexit_p(ipw2100_pci_remove_one),
6627 #ifdef CONFIG_PM 6627 #ifdef CONFIG_PM
6628 .suspend = ipw2100_suspend, 6628 .suspend = ipw2100_suspend,
6629 .resume = ipw2100_resume, 6629 .resume = ipw2100_resume,
6630 #endif 6630 #endif
6631 .shutdown = ipw2100_shutdown, 6631 .shutdown = ipw2100_shutdown,
6632 }; 6632 };
6633 6633
6634 /** 6634 /**
6635 * Initialize the ipw2100 driver/module 6635 * Initialize the ipw2100 driver/module
6636 * 6636 *
6637 * @returns 0 if ok, < 0 errno node con error. 6637 * @returns 0 if ok, < 0 errno node con error.
6638 * 6638 *
6639 * Note: we cannot init the /proc stuff until the PCI driver is there, 6639 * Note: we cannot init the /proc stuff until the PCI driver is there,
6640 * or we risk an unlikely race condition on someone accessing 6640 * or we risk an unlikely race condition on someone accessing
6641 * uninitialized data in the PCI dev struct through /proc. 6641 * uninitialized data in the PCI dev struct through /proc.
6642 */ 6642 */
6643 static int __init ipw2100_init(void) 6643 static int __init ipw2100_init(void)
6644 { 6644 {
6645 int ret; 6645 int ret;
6646 6646
6647 printk(KERN_INFO DRV_NAME ": %s, %s\n", DRV_DESCRIPTION, DRV_VERSION); 6647 printk(KERN_INFO DRV_NAME ": %s, %s\n", DRV_DESCRIPTION, DRV_VERSION);
6648 printk(KERN_INFO DRV_NAME ": %s\n", DRV_COPYRIGHT); 6648 printk(KERN_INFO DRV_NAME ": %s\n", DRV_COPYRIGHT);
6649 6649
6650 pm_qos_add_request(&ipw2100_pm_qos_req, PM_QOS_CPU_DMA_LATENCY, 6650 pm_qos_add_request(&ipw2100_pm_qos_req, PM_QOS_CPU_DMA_LATENCY,
6651 PM_QOS_DEFAULT_VALUE); 6651 PM_QOS_DEFAULT_VALUE);
6652 6652
6653 ret = pci_register_driver(&ipw2100_pci_driver); 6653 ret = pci_register_driver(&ipw2100_pci_driver);
6654 if (ret) 6654 if (ret)
6655 goto out; 6655 goto out;
6656 6656
6657 #ifdef CONFIG_IPW2100_DEBUG 6657 #ifdef CONFIG_IPW2100_DEBUG
6658 ipw2100_debug_level = debug; 6658 ipw2100_debug_level = debug;
6659 ret = driver_create_file(&ipw2100_pci_driver.driver, 6659 ret = driver_create_file(&ipw2100_pci_driver.driver,
6660 &driver_attr_debug_level); 6660 &driver_attr_debug_level);
6661 #endif 6661 #endif
6662 6662
6663 out: 6663 out:
6664 return ret; 6664 return ret;
6665 } 6665 }
6666 6666
6667 /** 6667 /**
6668 * Cleanup ipw2100 driver registration 6668 * Cleanup ipw2100 driver registration
6669 */ 6669 */
6670 static void __exit ipw2100_exit(void) 6670 static void __exit ipw2100_exit(void)
6671 { 6671 {
6672 /* FIXME: IPG: check that we have no instances of the devices open */ 6672 /* FIXME: IPG: check that we have no instances of the devices open */
6673 #ifdef CONFIG_IPW2100_DEBUG 6673 #ifdef CONFIG_IPW2100_DEBUG
6674 driver_remove_file(&ipw2100_pci_driver.driver, 6674 driver_remove_file(&ipw2100_pci_driver.driver,
6675 &driver_attr_debug_level); 6675 &driver_attr_debug_level);
6676 #endif 6676 #endif
6677 pci_unregister_driver(&ipw2100_pci_driver); 6677 pci_unregister_driver(&ipw2100_pci_driver);
6678 pm_qos_remove_request(&ipw2100_pm_qos_req); 6678 pm_qos_remove_request(&ipw2100_pm_qos_req);
6679 } 6679 }
6680 6680
6681 module_init(ipw2100_init); 6681 module_init(ipw2100_init);
6682 module_exit(ipw2100_exit); 6682 module_exit(ipw2100_exit);
6683 6683
6684 static int ipw2100_wx_get_name(struct net_device *dev, 6684 static int ipw2100_wx_get_name(struct net_device *dev,
6685 struct iw_request_info *info, 6685 struct iw_request_info *info,
6686 union iwreq_data *wrqu, char *extra) 6686 union iwreq_data *wrqu, char *extra)
6687 { 6687 {
6688 /* 6688 /*
6689 * This can be called at any time. No action lock required 6689 * This can be called at any time. No action lock required
6690 */ 6690 */
6691 6691
6692 struct ipw2100_priv *priv = libipw_priv(dev); 6692 struct ipw2100_priv *priv = libipw_priv(dev);
6693 if (!(priv->status & STATUS_ASSOCIATED)) 6693 if (!(priv->status & STATUS_ASSOCIATED))
6694 strcpy(wrqu->name, "unassociated"); 6694 strcpy(wrqu->name, "unassociated");
6695 else 6695 else
6696 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11b"); 6696 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11b");
6697 6697
6698 IPW_DEBUG_WX("Name: %s\n", wrqu->name); 6698 IPW_DEBUG_WX("Name: %s\n", wrqu->name);
6699 return 0; 6699 return 0;
6700 } 6700 }
6701 6701
6702 static int ipw2100_wx_set_freq(struct net_device *dev, 6702 static int ipw2100_wx_set_freq(struct net_device *dev,
6703 struct iw_request_info *info, 6703 struct iw_request_info *info,
6704 union iwreq_data *wrqu, char *extra) 6704 union iwreq_data *wrqu, char *extra)
6705 { 6705 {
6706 struct ipw2100_priv *priv = libipw_priv(dev); 6706 struct ipw2100_priv *priv = libipw_priv(dev);
6707 struct iw_freq *fwrq = &wrqu->freq; 6707 struct iw_freq *fwrq = &wrqu->freq;
6708 int err = 0; 6708 int err = 0;
6709 6709
6710 if (priv->ieee->iw_mode == IW_MODE_INFRA) 6710 if (priv->ieee->iw_mode == IW_MODE_INFRA)
6711 return -EOPNOTSUPP; 6711 return -EOPNOTSUPP;
6712 6712
6713 mutex_lock(&priv->action_mutex); 6713 mutex_lock(&priv->action_mutex);
6714 if (!(priv->status & STATUS_INITIALIZED)) { 6714 if (!(priv->status & STATUS_INITIALIZED)) {
6715 err = -EIO; 6715 err = -EIO;
6716 goto done; 6716 goto done;
6717 } 6717 }
6718 6718
6719 /* if setting by freq convert to channel */ 6719 /* if setting by freq convert to channel */
6720 if (fwrq->e == 1) { 6720 if (fwrq->e == 1) {
6721 if ((fwrq->m >= (int)2.412e8 && fwrq->m <= (int)2.487e8)) { 6721 if ((fwrq->m >= (int)2.412e8 && fwrq->m <= (int)2.487e8)) {
6722 int f = fwrq->m / 100000; 6722 int f = fwrq->m / 100000;
6723 int c = 0; 6723 int c = 0;
6724 6724
6725 while ((c < REG_MAX_CHANNEL) && 6725 while ((c < REG_MAX_CHANNEL) &&
6726 (f != ipw2100_frequencies[c])) 6726 (f != ipw2100_frequencies[c]))
6727 c++; 6727 c++;
6728 6728
6729 /* hack to fall through */ 6729 /* hack to fall through */
6730 fwrq->e = 0; 6730 fwrq->e = 0;
6731 fwrq->m = c + 1; 6731 fwrq->m = c + 1;
6732 } 6732 }
6733 } 6733 }
6734 6734
6735 if (fwrq->e > 0 || fwrq->m > 1000) { 6735 if (fwrq->e > 0 || fwrq->m > 1000) {
6736 err = -EOPNOTSUPP; 6736 err = -EOPNOTSUPP;
6737 goto done; 6737 goto done;
6738 } else { /* Set the channel */ 6738 } else { /* Set the channel */
6739 IPW_DEBUG_WX("SET Freq/Channel -> %d\n", fwrq->m); 6739 IPW_DEBUG_WX("SET Freq/Channel -> %d\n", fwrq->m);
6740 err = ipw2100_set_channel(priv, fwrq->m, 0); 6740 err = ipw2100_set_channel(priv, fwrq->m, 0);
6741 } 6741 }
6742 6742
6743 done: 6743 done:
6744 mutex_unlock(&priv->action_mutex); 6744 mutex_unlock(&priv->action_mutex);
6745 return err; 6745 return err;
6746 } 6746 }
6747 6747
6748 static int ipw2100_wx_get_freq(struct net_device *dev, 6748 static int ipw2100_wx_get_freq(struct net_device *dev,
6749 struct iw_request_info *info, 6749 struct iw_request_info *info,
6750 union iwreq_data *wrqu, char *extra) 6750 union iwreq_data *wrqu, char *extra)
6751 { 6751 {
6752 /* 6752 /*
6753 * This can be called at any time. No action lock required 6753 * This can be called at any time. No action lock required
6754 */ 6754 */
6755 6755
6756 struct ipw2100_priv *priv = libipw_priv(dev); 6756 struct ipw2100_priv *priv = libipw_priv(dev);
6757 6757
6758 wrqu->freq.e = 0; 6758 wrqu->freq.e = 0;
6759 6759
6760 /* If we are associated, trying to associate, or have a statically 6760 /* If we are associated, trying to associate, or have a statically
6761 * configured CHANNEL then return that; otherwise return ANY */ 6761 * configured CHANNEL then return that; otherwise return ANY */
6762 if (priv->config & CFG_STATIC_CHANNEL || 6762 if (priv->config & CFG_STATIC_CHANNEL ||
6763 priv->status & STATUS_ASSOCIATED) 6763 priv->status & STATUS_ASSOCIATED)
6764 wrqu->freq.m = priv->channel; 6764 wrqu->freq.m = priv->channel;
6765 else 6765 else
6766 wrqu->freq.m = 0; 6766 wrqu->freq.m = 0;
6767 6767
6768 IPW_DEBUG_WX("GET Freq/Channel -> %d\n", priv->channel); 6768 IPW_DEBUG_WX("GET Freq/Channel -> %d\n", priv->channel);
6769 return 0; 6769 return 0;
6770 6770
6771 } 6771 }
6772 6772
6773 static int ipw2100_wx_set_mode(struct net_device *dev, 6773 static int ipw2100_wx_set_mode(struct net_device *dev,
6774 struct iw_request_info *info, 6774 struct iw_request_info *info,
6775 union iwreq_data *wrqu, char *extra) 6775 union iwreq_data *wrqu, char *extra)
6776 { 6776 {
6777 struct ipw2100_priv *priv = libipw_priv(dev); 6777 struct ipw2100_priv *priv = libipw_priv(dev);
6778 int err = 0; 6778 int err = 0;
6779 6779
6780 IPW_DEBUG_WX("SET Mode -> %d\n", wrqu->mode); 6780 IPW_DEBUG_WX("SET Mode -> %d\n", wrqu->mode);
6781 6781
6782 if (wrqu->mode == priv->ieee->iw_mode) 6782 if (wrqu->mode == priv->ieee->iw_mode)
6783 return 0; 6783 return 0;
6784 6784
6785 mutex_lock(&priv->action_mutex); 6785 mutex_lock(&priv->action_mutex);
6786 if (!(priv->status & STATUS_INITIALIZED)) { 6786 if (!(priv->status & STATUS_INITIALIZED)) {
6787 err = -EIO; 6787 err = -EIO;
6788 goto done; 6788 goto done;
6789 } 6789 }
6790 6790
6791 switch (wrqu->mode) { 6791 switch (wrqu->mode) {
6792 #ifdef CONFIG_IPW2100_MONITOR 6792 #ifdef CONFIG_IPW2100_MONITOR
6793 case IW_MODE_MONITOR: 6793 case IW_MODE_MONITOR:
6794 err = ipw2100_switch_mode(priv, IW_MODE_MONITOR); 6794 err = ipw2100_switch_mode(priv, IW_MODE_MONITOR);
6795 break; 6795 break;
6796 #endif /* CONFIG_IPW2100_MONITOR */ 6796 #endif /* CONFIG_IPW2100_MONITOR */
6797 case IW_MODE_ADHOC: 6797 case IW_MODE_ADHOC:
6798 err = ipw2100_switch_mode(priv, IW_MODE_ADHOC); 6798 err = ipw2100_switch_mode(priv, IW_MODE_ADHOC);
6799 break; 6799 break;
6800 case IW_MODE_INFRA: 6800 case IW_MODE_INFRA:
6801 case IW_MODE_AUTO: 6801 case IW_MODE_AUTO:
6802 default: 6802 default:
6803 err = ipw2100_switch_mode(priv, IW_MODE_INFRA); 6803 err = ipw2100_switch_mode(priv, IW_MODE_INFRA);
6804 break; 6804 break;
6805 } 6805 }
6806 6806
6807 done: 6807 done:
6808 mutex_unlock(&priv->action_mutex); 6808 mutex_unlock(&priv->action_mutex);
6809 return err; 6809 return err;
6810 } 6810 }
6811 6811
6812 static int ipw2100_wx_get_mode(struct net_device *dev, 6812 static int ipw2100_wx_get_mode(struct net_device *dev,
6813 struct iw_request_info *info, 6813 struct iw_request_info *info,
6814 union iwreq_data *wrqu, char *extra) 6814 union iwreq_data *wrqu, char *extra)
6815 { 6815 {
6816 /* 6816 /*
6817 * This can be called at any time. No action lock required 6817 * This can be called at any time. No action lock required
6818 */ 6818 */
6819 6819
6820 struct ipw2100_priv *priv = libipw_priv(dev); 6820 struct ipw2100_priv *priv = libipw_priv(dev);
6821 6821
6822 wrqu->mode = priv->ieee->iw_mode; 6822 wrqu->mode = priv->ieee->iw_mode;
6823 IPW_DEBUG_WX("GET Mode -> %d\n", wrqu->mode); 6823 IPW_DEBUG_WX("GET Mode -> %d\n", wrqu->mode);
6824 6824
6825 return 0; 6825 return 0;
6826 } 6826 }
6827 6827
6828 #define POWER_MODES 5 6828 #define POWER_MODES 5
6829 6829
6830 /* Values are in microsecond */ 6830 /* Values are in microsecond */
6831 static const s32 timeout_duration[POWER_MODES] = { 6831 static const s32 timeout_duration[POWER_MODES] = {
6832 350000, 6832 350000,
6833 250000, 6833 250000,
6834 75000, 6834 75000,
6835 37000, 6835 37000,
6836 25000, 6836 25000,
6837 }; 6837 };
6838 6838
6839 static const s32 period_duration[POWER_MODES] = { 6839 static const s32 period_duration[POWER_MODES] = {
6840 400000, 6840 400000,
6841 700000, 6841 700000,
6842 1000000, 6842 1000000,
6843 1000000, 6843 1000000,
6844 1000000 6844 1000000
6845 }; 6845 };
6846 6846
6847 static int ipw2100_wx_get_range(struct net_device *dev, 6847 static int ipw2100_wx_get_range(struct net_device *dev,
6848 struct iw_request_info *info, 6848 struct iw_request_info *info,
6849 union iwreq_data *wrqu, char *extra) 6849 union iwreq_data *wrqu, char *extra)
6850 { 6850 {
6851 /* 6851 /*
6852 * This can be called at any time. No action lock required 6852 * This can be called at any time. No action lock required
6853 */ 6853 */
6854 6854
6855 struct ipw2100_priv *priv = libipw_priv(dev); 6855 struct ipw2100_priv *priv = libipw_priv(dev);
6856 struct iw_range *range = (struct iw_range *)extra; 6856 struct iw_range *range = (struct iw_range *)extra;
6857 u16 val; 6857 u16 val;
6858 int i, level; 6858 int i, level;
6859 6859
6860 wrqu->data.length = sizeof(*range); 6860 wrqu->data.length = sizeof(*range);
6861 memset(range, 0, sizeof(*range)); 6861 memset(range, 0, sizeof(*range));
6862 6862
6863 /* Let's try to keep this struct in the same order as in 6863 /* Let's try to keep this struct in the same order as in
6864 * linux/include/wireless.h 6864 * linux/include/wireless.h
6865 */ 6865 */
6866 6866
6867 /* TODO: See what values we can set, and remove the ones we can't 6867 /* TODO: See what values we can set, and remove the ones we can't
6868 * set, or fill them with some default data. 6868 * set, or fill them with some default data.
6869 */ 6869 */
6870 6870
6871 /* ~5 Mb/s real (802.11b) */ 6871 /* ~5 Mb/s real (802.11b) */
6872 range->throughput = 5 * 1000 * 1000; 6872 range->throughput = 5 * 1000 * 1000;
6873 6873
6874 // range->sensitivity; /* signal level threshold range */ 6874 // range->sensitivity; /* signal level threshold range */
6875 6875
6876 range->max_qual.qual = 100; 6876 range->max_qual.qual = 100;
6877 /* TODO: Find real max RSSI and stick here */ 6877 /* TODO: Find real max RSSI and stick here */
6878 range->max_qual.level = 0; 6878 range->max_qual.level = 0;
6879 range->max_qual.noise = 0; 6879 range->max_qual.noise = 0;
6880 range->max_qual.updated = 7; /* Updated all three */ 6880 range->max_qual.updated = 7; /* Updated all three */
6881 6881
6882 range->avg_qual.qual = 70; /* > 8% missed beacons is 'bad' */ 6882 range->avg_qual.qual = 70; /* > 8% missed beacons is 'bad' */
6883 /* TODO: Find real 'good' to 'bad' threshold value for RSSI */ 6883 /* TODO: Find real 'good' to 'bad' threshold value for RSSI */
6884 range->avg_qual.level = 20 + IPW2100_RSSI_TO_DBM; 6884 range->avg_qual.level = 20 + IPW2100_RSSI_TO_DBM;
6885 range->avg_qual.noise = 0; 6885 range->avg_qual.noise = 0;
6886 range->avg_qual.updated = 7; /* Updated all three */ 6886 range->avg_qual.updated = 7; /* Updated all three */
6887 6887
6888 range->num_bitrates = RATE_COUNT; 6888 range->num_bitrates = RATE_COUNT;
6889 6889
6890 for (i = 0; i < RATE_COUNT && i < IW_MAX_BITRATES; i++) { 6890 for (i = 0; i < RATE_COUNT && i < IW_MAX_BITRATES; i++) {
6891 range->bitrate[i] = ipw2100_rates_11b[i]; 6891 range->bitrate[i] = ipw2100_rates_11b[i];
6892 } 6892 }
6893 6893
6894 range->min_rts = MIN_RTS_THRESHOLD; 6894 range->min_rts = MIN_RTS_THRESHOLD;
6895 range->max_rts = MAX_RTS_THRESHOLD; 6895 range->max_rts = MAX_RTS_THRESHOLD;
6896 range->min_frag = MIN_FRAG_THRESHOLD; 6896 range->min_frag = MIN_FRAG_THRESHOLD;
6897 range->max_frag = MAX_FRAG_THRESHOLD; 6897 range->max_frag = MAX_FRAG_THRESHOLD;
6898 6898
6899 range->min_pmp = period_duration[0]; /* Minimal PM period */ 6899 range->min_pmp = period_duration[0]; /* Minimal PM period */
6900 range->max_pmp = period_duration[POWER_MODES - 1]; /* Maximal PM period */ 6900 range->max_pmp = period_duration[POWER_MODES - 1]; /* Maximal PM period */
6901 range->min_pmt = timeout_duration[POWER_MODES - 1]; /* Minimal PM timeout */ 6901 range->min_pmt = timeout_duration[POWER_MODES - 1]; /* Minimal PM timeout */
6902 range->max_pmt = timeout_duration[0]; /* Maximal PM timeout */ 6902 range->max_pmt = timeout_duration[0]; /* Maximal PM timeout */
6903 6903
6904 /* How to decode max/min PM period */ 6904 /* How to decode max/min PM period */
6905 range->pmp_flags = IW_POWER_PERIOD; 6905 range->pmp_flags = IW_POWER_PERIOD;
6906 /* How to decode max/min PM period */ 6906 /* How to decode max/min PM period */
6907 range->pmt_flags = IW_POWER_TIMEOUT; 6907 range->pmt_flags = IW_POWER_TIMEOUT;
6908 /* What PM options are supported */ 6908 /* What PM options are supported */
6909 range->pm_capa = IW_POWER_TIMEOUT | IW_POWER_PERIOD; 6909 range->pm_capa = IW_POWER_TIMEOUT | IW_POWER_PERIOD;
6910 6910
6911 range->encoding_size[0] = 5; 6911 range->encoding_size[0] = 5;
6912 range->encoding_size[1] = 13; /* Different token sizes */ 6912 range->encoding_size[1] = 13; /* Different token sizes */
6913 range->num_encoding_sizes = 2; /* Number of entry in the list */ 6913 range->num_encoding_sizes = 2; /* Number of entry in the list */
6914 range->max_encoding_tokens = WEP_KEYS; /* Max number of tokens */ 6914 range->max_encoding_tokens = WEP_KEYS; /* Max number of tokens */
6915 // range->encoding_login_index; /* token index for login token */ 6915 // range->encoding_login_index; /* token index for login token */
6916 6916
6917 if (priv->ieee->iw_mode == IW_MODE_ADHOC) { 6917 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6918 range->txpower_capa = IW_TXPOW_DBM; 6918 range->txpower_capa = IW_TXPOW_DBM;
6919 range->num_txpower = IW_MAX_TXPOWER; 6919 range->num_txpower = IW_MAX_TXPOWER;
6920 for (i = 0, level = (IPW_TX_POWER_MAX_DBM * 16); 6920 for (i = 0, level = (IPW_TX_POWER_MAX_DBM * 16);
6921 i < IW_MAX_TXPOWER; 6921 i < IW_MAX_TXPOWER;
6922 i++, level -= 6922 i++, level -=
6923 ((IPW_TX_POWER_MAX_DBM - 6923 ((IPW_TX_POWER_MAX_DBM -
6924 IPW_TX_POWER_MIN_DBM) * 16) / (IW_MAX_TXPOWER - 1)) 6924 IPW_TX_POWER_MIN_DBM) * 16) / (IW_MAX_TXPOWER - 1))
6925 range->txpower[i] = level / 16; 6925 range->txpower[i] = level / 16;
6926 } else { 6926 } else {
6927 range->txpower_capa = 0; 6927 range->txpower_capa = 0;
6928 range->num_txpower = 0; 6928 range->num_txpower = 0;
6929 } 6929 }
6930 6930
6931 /* Set the Wireless Extension versions */ 6931 /* Set the Wireless Extension versions */
6932 range->we_version_compiled = WIRELESS_EXT; 6932 range->we_version_compiled = WIRELESS_EXT;
6933 range->we_version_source = 18; 6933 range->we_version_source = 18;
6934 6934
6935 // range->retry_capa; /* What retry options are supported */ 6935 // range->retry_capa; /* What retry options are supported */
6936 // range->retry_flags; /* How to decode max/min retry limit */ 6936 // range->retry_flags; /* How to decode max/min retry limit */
6937 // range->r_time_flags; /* How to decode max/min retry life */ 6937 // range->r_time_flags; /* How to decode max/min retry life */
6938 // range->min_retry; /* Minimal number of retries */ 6938 // range->min_retry; /* Minimal number of retries */
6939 // range->max_retry; /* Maximal number of retries */ 6939 // range->max_retry; /* Maximal number of retries */
6940 // range->min_r_time; /* Minimal retry lifetime */ 6940 // range->min_r_time; /* Minimal retry lifetime */
6941 // range->max_r_time; /* Maximal retry lifetime */ 6941 // range->max_r_time; /* Maximal retry lifetime */
6942 6942
6943 range->num_channels = FREQ_COUNT; 6943 range->num_channels = FREQ_COUNT;
6944 6944
6945 val = 0; 6945 val = 0;
6946 for (i = 0; i < FREQ_COUNT; i++) { 6946 for (i = 0; i < FREQ_COUNT; i++) {
6947 // TODO: Include only legal frequencies for some countries 6947 // TODO: Include only legal frequencies for some countries
6948 // if (local->channel_mask & (1 << i)) { 6948 // if (local->channel_mask & (1 << i)) {
6949 range->freq[val].i = i + 1; 6949 range->freq[val].i = i + 1;
6950 range->freq[val].m = ipw2100_frequencies[i] * 100000; 6950 range->freq[val].m = ipw2100_frequencies[i] * 100000;
6951 range->freq[val].e = 1; 6951 range->freq[val].e = 1;
6952 val++; 6952 val++;
6953 // } 6953 // }
6954 if (val == IW_MAX_FREQUENCIES) 6954 if (val == IW_MAX_FREQUENCIES)
6955 break; 6955 break;
6956 } 6956 }
6957 range->num_frequency = val; 6957 range->num_frequency = val;
6958 6958
6959 /* Event capability (kernel + driver) */ 6959 /* Event capability (kernel + driver) */
6960 range->event_capa[0] = (IW_EVENT_CAPA_K_0 | 6960 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
6961 IW_EVENT_CAPA_MASK(SIOCGIWAP)); 6961 IW_EVENT_CAPA_MASK(SIOCGIWAP));
6962 range->event_capa[1] = IW_EVENT_CAPA_K_1; 6962 range->event_capa[1] = IW_EVENT_CAPA_K_1;
6963 6963
6964 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 | 6964 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
6965 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP; 6965 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
6966 6966
6967 IPW_DEBUG_WX("GET Range\n"); 6967 IPW_DEBUG_WX("GET Range\n");
6968 6968
6969 return 0; 6969 return 0;
6970 } 6970 }
6971 6971
6972 static int ipw2100_wx_set_wap(struct net_device *dev, 6972 static int ipw2100_wx_set_wap(struct net_device *dev,
6973 struct iw_request_info *info, 6973 struct iw_request_info *info,
6974 union iwreq_data *wrqu, char *extra) 6974 union iwreq_data *wrqu, char *extra)
6975 { 6975 {
6976 struct ipw2100_priv *priv = libipw_priv(dev); 6976 struct ipw2100_priv *priv = libipw_priv(dev);
6977 int err = 0; 6977 int err = 0;
6978 6978
6979 static const unsigned char any[] = { 6979 static const unsigned char any[] = {
6980 0xff, 0xff, 0xff, 0xff, 0xff, 0xff 6980 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
6981 }; 6981 };
6982 static const unsigned char off[] = { 6982 static const unsigned char off[] = {
6983 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 6983 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
6984 }; 6984 };
6985 6985
6986 // sanity checks 6986 // sanity checks
6987 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER) 6987 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
6988 return -EINVAL; 6988 return -EINVAL;
6989 6989
6990 mutex_lock(&priv->action_mutex); 6990 mutex_lock(&priv->action_mutex);
6991 if (!(priv->status & STATUS_INITIALIZED)) { 6991 if (!(priv->status & STATUS_INITIALIZED)) {
6992 err = -EIO; 6992 err = -EIO;
6993 goto done; 6993 goto done;
6994 } 6994 }
6995 6995
6996 if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) || 6996 if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
6997 !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) { 6997 !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
6998 /* we disable mandatory BSSID association */ 6998 /* we disable mandatory BSSID association */
6999 IPW_DEBUG_WX("exit - disable mandatory BSSID\n"); 6999 IPW_DEBUG_WX("exit - disable mandatory BSSID\n");
7000 priv->config &= ~CFG_STATIC_BSSID; 7000 priv->config &= ~CFG_STATIC_BSSID;
7001 err = ipw2100_set_mandatory_bssid(priv, NULL, 0); 7001 err = ipw2100_set_mandatory_bssid(priv, NULL, 0);
7002 goto done; 7002 goto done;
7003 } 7003 }
7004 7004
7005 priv->config |= CFG_STATIC_BSSID; 7005 priv->config |= CFG_STATIC_BSSID;
7006 memcpy(priv->mandatory_bssid_mac, wrqu->ap_addr.sa_data, ETH_ALEN); 7006 memcpy(priv->mandatory_bssid_mac, wrqu->ap_addr.sa_data, ETH_ALEN);
7007 7007
7008 err = ipw2100_set_mandatory_bssid(priv, wrqu->ap_addr.sa_data, 0); 7008 err = ipw2100_set_mandatory_bssid(priv, wrqu->ap_addr.sa_data, 0);
7009 7009
7010 IPW_DEBUG_WX("SET BSSID -> %pM\n", wrqu->ap_addr.sa_data); 7010 IPW_DEBUG_WX("SET BSSID -> %pM\n", wrqu->ap_addr.sa_data);
7011 7011
7012 done: 7012 done:
7013 mutex_unlock(&priv->action_mutex); 7013 mutex_unlock(&priv->action_mutex);
7014 return err; 7014 return err;
7015 } 7015 }
7016 7016
7017 static int ipw2100_wx_get_wap(struct net_device *dev, 7017 static int ipw2100_wx_get_wap(struct net_device *dev,
7018 struct iw_request_info *info, 7018 struct iw_request_info *info,
7019 union iwreq_data *wrqu, char *extra) 7019 union iwreq_data *wrqu, char *extra)
7020 { 7020 {
7021 /* 7021 /*
7022 * This can be called at any time. No action lock required 7022 * This can be called at any time. No action lock required
7023 */ 7023 */
7024 7024
7025 struct ipw2100_priv *priv = libipw_priv(dev); 7025 struct ipw2100_priv *priv = libipw_priv(dev);
7026 7026
7027 /* If we are associated, trying to associate, or have a statically 7027 /* If we are associated, trying to associate, or have a statically
7028 * configured BSSID then return that; otherwise return ANY */ 7028 * configured BSSID then return that; otherwise return ANY */
7029 if (priv->config & CFG_STATIC_BSSID || priv->status & STATUS_ASSOCIATED) { 7029 if (priv->config & CFG_STATIC_BSSID || priv->status & STATUS_ASSOCIATED) {
7030 wrqu->ap_addr.sa_family = ARPHRD_ETHER; 7030 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
7031 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN); 7031 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
7032 } else 7032 } else
7033 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN); 7033 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
7034 7034
7035 IPW_DEBUG_WX("Getting WAP BSSID: %pM\n", wrqu->ap_addr.sa_data); 7035 IPW_DEBUG_WX("Getting WAP BSSID: %pM\n", wrqu->ap_addr.sa_data);
7036 return 0; 7036 return 0;
7037 } 7037 }
7038 7038
7039 static int ipw2100_wx_set_essid(struct net_device *dev, 7039 static int ipw2100_wx_set_essid(struct net_device *dev,
7040 struct iw_request_info *info, 7040 struct iw_request_info *info,
7041 union iwreq_data *wrqu, char *extra) 7041 union iwreq_data *wrqu, char *extra)
7042 { 7042 {
7043 struct ipw2100_priv *priv = libipw_priv(dev); 7043 struct ipw2100_priv *priv = libipw_priv(dev);
7044 char *essid = ""; /* ANY */ 7044 char *essid = ""; /* ANY */
7045 int length = 0; 7045 int length = 0;
7046 int err = 0; 7046 int err = 0;
7047 DECLARE_SSID_BUF(ssid); 7047 DECLARE_SSID_BUF(ssid);
7048 7048
7049 mutex_lock(&priv->action_mutex); 7049 mutex_lock(&priv->action_mutex);
7050 if (!(priv->status & STATUS_INITIALIZED)) { 7050 if (!(priv->status & STATUS_INITIALIZED)) {
7051 err = -EIO; 7051 err = -EIO;
7052 goto done; 7052 goto done;
7053 } 7053 }
7054 7054
7055 if (wrqu->essid.flags && wrqu->essid.length) { 7055 if (wrqu->essid.flags && wrqu->essid.length) {
7056 length = wrqu->essid.length; 7056 length = wrqu->essid.length;
7057 essid = extra; 7057 essid = extra;
7058 } 7058 }
7059 7059
7060 if (length == 0) { 7060 if (length == 0) {
7061 IPW_DEBUG_WX("Setting ESSID to ANY\n"); 7061 IPW_DEBUG_WX("Setting ESSID to ANY\n");
7062 priv->config &= ~CFG_STATIC_ESSID; 7062 priv->config &= ~CFG_STATIC_ESSID;
7063 err = ipw2100_set_essid(priv, NULL, 0, 0); 7063 err = ipw2100_set_essid(priv, NULL, 0, 0);
7064 goto done; 7064 goto done;
7065 } 7065 }
7066 7066
7067 length = min(length, IW_ESSID_MAX_SIZE); 7067 length = min(length, IW_ESSID_MAX_SIZE);
7068 7068
7069 priv->config |= CFG_STATIC_ESSID; 7069 priv->config |= CFG_STATIC_ESSID;
7070 7070
7071 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) { 7071 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) {
7072 IPW_DEBUG_WX("ESSID set to current ESSID.\n"); 7072 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
7073 err = 0; 7073 err = 0;
7074 goto done; 7074 goto done;
7075 } 7075 }
7076 7076
7077 IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n", 7077 IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n",
7078 print_ssid(ssid, essid, length), length); 7078 print_ssid(ssid, essid, length), length);
7079 7079
7080 priv->essid_len = length; 7080 priv->essid_len = length;
7081 memcpy(priv->essid, essid, priv->essid_len); 7081 memcpy(priv->essid, essid, priv->essid_len);
7082 7082
7083 err = ipw2100_set_essid(priv, essid, length, 0); 7083 err = ipw2100_set_essid(priv, essid, length, 0);
7084 7084
7085 done: 7085 done:
7086 mutex_unlock(&priv->action_mutex); 7086 mutex_unlock(&priv->action_mutex);
7087 return err; 7087 return err;
7088 } 7088 }
7089 7089
7090 static int ipw2100_wx_get_essid(struct net_device *dev, 7090 static int ipw2100_wx_get_essid(struct net_device *dev,
7091 struct iw_request_info *info, 7091 struct iw_request_info *info,
7092 union iwreq_data *wrqu, char *extra) 7092 union iwreq_data *wrqu, char *extra)
7093 { 7093 {
7094 /* 7094 /*
7095 * This can be called at any time. No action lock required 7095 * This can be called at any time. No action lock required
7096 */ 7096 */
7097 7097
7098 struct ipw2100_priv *priv = libipw_priv(dev); 7098 struct ipw2100_priv *priv = libipw_priv(dev);
7099 DECLARE_SSID_BUF(ssid); 7099 DECLARE_SSID_BUF(ssid);
7100 7100
7101 /* If we are associated, trying to associate, or have a statically 7101 /* If we are associated, trying to associate, or have a statically
7102 * configured ESSID then return that; otherwise return ANY */ 7102 * configured ESSID then return that; otherwise return ANY */
7103 if (priv->config & CFG_STATIC_ESSID || priv->status & STATUS_ASSOCIATED) { 7103 if (priv->config & CFG_STATIC_ESSID || priv->status & STATUS_ASSOCIATED) {
7104 IPW_DEBUG_WX("Getting essid: '%s'\n", 7104 IPW_DEBUG_WX("Getting essid: '%s'\n",
7105 print_ssid(ssid, priv->essid, priv->essid_len)); 7105 print_ssid(ssid, priv->essid, priv->essid_len));
7106 memcpy(extra, priv->essid, priv->essid_len); 7106 memcpy(extra, priv->essid, priv->essid_len);
7107 wrqu->essid.length = priv->essid_len; 7107 wrqu->essid.length = priv->essid_len;
7108 wrqu->essid.flags = 1; /* active */ 7108 wrqu->essid.flags = 1; /* active */
7109 } else { 7109 } else {
7110 IPW_DEBUG_WX("Getting essid: ANY\n"); 7110 IPW_DEBUG_WX("Getting essid: ANY\n");
7111 wrqu->essid.length = 0; 7111 wrqu->essid.length = 0;
7112 wrqu->essid.flags = 0; /* active */ 7112 wrqu->essid.flags = 0; /* active */
7113 } 7113 }
7114 7114
7115 return 0; 7115 return 0;
7116 } 7116 }
7117 7117
7118 static int ipw2100_wx_set_nick(struct net_device *dev, 7118 static int ipw2100_wx_set_nick(struct net_device *dev,
7119 struct iw_request_info *info, 7119 struct iw_request_info *info,
7120 union iwreq_data *wrqu, char *extra) 7120 union iwreq_data *wrqu, char *extra)
7121 { 7121 {
7122 /* 7122 /*
7123 * This can be called at any time. No action lock required 7123 * This can be called at any time. No action lock required
7124 */ 7124 */
7125 7125
7126 struct ipw2100_priv *priv = libipw_priv(dev); 7126 struct ipw2100_priv *priv = libipw_priv(dev);
7127 7127
7128 if (wrqu->data.length > IW_ESSID_MAX_SIZE) 7128 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
7129 return -E2BIG; 7129 return -E2BIG;
7130 7130
7131 wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick)); 7131 wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
7132 memset(priv->nick, 0, sizeof(priv->nick)); 7132 memset(priv->nick, 0, sizeof(priv->nick));
7133 memcpy(priv->nick, extra, wrqu->data.length); 7133 memcpy(priv->nick, extra, wrqu->data.length);
7134 7134
7135 IPW_DEBUG_WX("SET Nickname -> %s\n", priv->nick); 7135 IPW_DEBUG_WX("SET Nickname -> %s\n", priv->nick);
7136 7136
7137 return 0; 7137 return 0;
7138 } 7138 }
7139 7139
7140 static int ipw2100_wx_get_nick(struct net_device *dev, 7140 static int ipw2100_wx_get_nick(struct net_device *dev,
7141 struct iw_request_info *info, 7141 struct iw_request_info *info,
7142 union iwreq_data *wrqu, char *extra) 7142 union iwreq_data *wrqu, char *extra)
7143 { 7143 {
7144 /* 7144 /*
7145 * This can be called at any time. No action lock required 7145 * This can be called at any time. No action lock required
7146 */ 7146 */
7147 7147
7148 struct ipw2100_priv *priv = libipw_priv(dev); 7148 struct ipw2100_priv *priv = libipw_priv(dev);
7149 7149
7150 wrqu->data.length = strlen(priv->nick); 7150 wrqu->data.length = strlen(priv->nick);
7151 memcpy(extra, priv->nick, wrqu->data.length); 7151 memcpy(extra, priv->nick, wrqu->data.length);
7152 wrqu->data.flags = 1; /* active */ 7152 wrqu->data.flags = 1; /* active */
7153 7153
7154 IPW_DEBUG_WX("GET Nickname -> %s\n", extra); 7154 IPW_DEBUG_WX("GET Nickname -> %s\n", extra);
7155 7155
7156 return 0; 7156 return 0;
7157 } 7157 }
7158 7158
7159 static int ipw2100_wx_set_rate(struct net_device *dev, 7159 static int ipw2100_wx_set_rate(struct net_device *dev,
7160 struct iw_request_info *info, 7160 struct iw_request_info *info,
7161 union iwreq_data *wrqu, char *extra) 7161 union iwreq_data *wrqu, char *extra)
7162 { 7162 {
7163 struct ipw2100_priv *priv = libipw_priv(dev); 7163 struct ipw2100_priv *priv = libipw_priv(dev);
7164 u32 target_rate = wrqu->bitrate.value; 7164 u32 target_rate = wrqu->bitrate.value;
7165 u32 rate; 7165 u32 rate;
7166 int err = 0; 7166 int err = 0;
7167 7167
7168 mutex_lock(&priv->action_mutex); 7168 mutex_lock(&priv->action_mutex);
7169 if (!(priv->status & STATUS_INITIALIZED)) { 7169 if (!(priv->status & STATUS_INITIALIZED)) {
7170 err = -EIO; 7170 err = -EIO;
7171 goto done; 7171 goto done;
7172 } 7172 }
7173 7173
7174 rate = 0; 7174 rate = 0;
7175 7175
7176 if (target_rate == 1000000 || 7176 if (target_rate == 1000000 ||
7177 (!wrqu->bitrate.fixed && target_rate > 1000000)) 7177 (!wrqu->bitrate.fixed && target_rate > 1000000))
7178 rate |= TX_RATE_1_MBIT; 7178 rate |= TX_RATE_1_MBIT;
7179 if (target_rate == 2000000 || 7179 if (target_rate == 2000000 ||
7180 (!wrqu->bitrate.fixed && target_rate > 2000000)) 7180 (!wrqu->bitrate.fixed && target_rate > 2000000))
7181 rate |= TX_RATE_2_MBIT; 7181 rate |= TX_RATE_2_MBIT;
7182 if (target_rate == 5500000 || 7182 if (target_rate == 5500000 ||
7183 (!wrqu->bitrate.fixed && target_rate > 5500000)) 7183 (!wrqu->bitrate.fixed && target_rate > 5500000))
7184 rate |= TX_RATE_5_5_MBIT; 7184 rate |= TX_RATE_5_5_MBIT;
7185 if (target_rate == 11000000 || 7185 if (target_rate == 11000000 ||
7186 (!wrqu->bitrate.fixed && target_rate > 11000000)) 7186 (!wrqu->bitrate.fixed && target_rate > 11000000))
7187 rate |= TX_RATE_11_MBIT; 7187 rate |= TX_RATE_11_MBIT;
7188 if (rate == 0) 7188 if (rate == 0)
7189 rate = DEFAULT_TX_RATES; 7189 rate = DEFAULT_TX_RATES;
7190 7190
7191 err = ipw2100_set_tx_rates(priv, rate, 0); 7191 err = ipw2100_set_tx_rates(priv, rate, 0);
7192 7192
7193 IPW_DEBUG_WX("SET Rate -> %04X\n", rate); 7193 IPW_DEBUG_WX("SET Rate -> %04X\n", rate);
7194 done: 7194 done:
7195 mutex_unlock(&priv->action_mutex); 7195 mutex_unlock(&priv->action_mutex);
7196 return err; 7196 return err;
7197 } 7197 }
7198 7198
7199 static int ipw2100_wx_get_rate(struct net_device *dev, 7199 static int ipw2100_wx_get_rate(struct net_device *dev,
7200 struct iw_request_info *info, 7200 struct iw_request_info *info,
7201 union iwreq_data *wrqu, char *extra) 7201 union iwreq_data *wrqu, char *extra)
7202 { 7202 {
7203 struct ipw2100_priv *priv = libipw_priv(dev); 7203 struct ipw2100_priv *priv = libipw_priv(dev);
7204 int val; 7204 int val;
7205 unsigned int len = sizeof(val); 7205 unsigned int len = sizeof(val);
7206 int err = 0; 7206 int err = 0;
7207 7207
7208 if (!(priv->status & STATUS_ENABLED) || 7208 if (!(priv->status & STATUS_ENABLED) ||
7209 priv->status & STATUS_RF_KILL_MASK || 7209 priv->status & STATUS_RF_KILL_MASK ||
7210 !(priv->status & STATUS_ASSOCIATED)) { 7210 !(priv->status & STATUS_ASSOCIATED)) {
7211 wrqu->bitrate.value = 0; 7211 wrqu->bitrate.value = 0;
7212 return 0; 7212 return 0;
7213 } 7213 }
7214 7214
7215 mutex_lock(&priv->action_mutex); 7215 mutex_lock(&priv->action_mutex);
7216 if (!(priv->status & STATUS_INITIALIZED)) { 7216 if (!(priv->status & STATUS_INITIALIZED)) {
7217 err = -EIO; 7217 err = -EIO;
7218 goto done; 7218 goto done;
7219 } 7219 }
7220 7220
7221 err = ipw2100_get_ordinal(priv, IPW_ORD_CURRENT_TX_RATE, &val, &len); 7221 err = ipw2100_get_ordinal(priv, IPW_ORD_CURRENT_TX_RATE, &val, &len);
7222 if (err) { 7222 if (err) {
7223 IPW_DEBUG_WX("failed querying ordinals.\n"); 7223 IPW_DEBUG_WX("failed querying ordinals.\n");
7224 goto done; 7224 goto done;
7225 } 7225 }
7226 7226
7227 switch (val & TX_RATE_MASK) { 7227 switch (val & TX_RATE_MASK) {
7228 case TX_RATE_1_MBIT: 7228 case TX_RATE_1_MBIT:
7229 wrqu->bitrate.value = 1000000; 7229 wrqu->bitrate.value = 1000000;
7230 break; 7230 break;
7231 case TX_RATE_2_MBIT: 7231 case TX_RATE_2_MBIT:
7232 wrqu->bitrate.value = 2000000; 7232 wrqu->bitrate.value = 2000000;
7233 break; 7233 break;
7234 case TX_RATE_5_5_MBIT: 7234 case TX_RATE_5_5_MBIT:
7235 wrqu->bitrate.value = 5500000; 7235 wrqu->bitrate.value = 5500000;
7236 break; 7236 break;
7237 case TX_RATE_11_MBIT: 7237 case TX_RATE_11_MBIT:
7238 wrqu->bitrate.value = 11000000; 7238 wrqu->bitrate.value = 11000000;
7239 break; 7239 break;
7240 default: 7240 default:
7241 wrqu->bitrate.value = 0; 7241 wrqu->bitrate.value = 0;
7242 } 7242 }
7243 7243
7244 IPW_DEBUG_WX("GET Rate -> %d\n", wrqu->bitrate.value); 7244 IPW_DEBUG_WX("GET Rate -> %d\n", wrqu->bitrate.value);
7245 7245
7246 done: 7246 done:
7247 mutex_unlock(&priv->action_mutex); 7247 mutex_unlock(&priv->action_mutex);
7248 return err; 7248 return err;
7249 } 7249 }
7250 7250
7251 static int ipw2100_wx_set_rts(struct net_device *dev, 7251 static int ipw2100_wx_set_rts(struct net_device *dev,
7252 struct iw_request_info *info, 7252 struct iw_request_info *info,
7253 union iwreq_data *wrqu, char *extra) 7253 union iwreq_data *wrqu, char *extra)
7254 { 7254 {
7255 struct ipw2100_priv *priv = libipw_priv(dev); 7255 struct ipw2100_priv *priv = libipw_priv(dev);
7256 int value, err; 7256 int value, err;
7257 7257
7258 /* Auto RTS not yet supported */ 7258 /* Auto RTS not yet supported */
7259 if (wrqu->rts.fixed == 0) 7259 if (wrqu->rts.fixed == 0)
7260 return -EINVAL; 7260 return -EINVAL;
7261 7261
7262 mutex_lock(&priv->action_mutex); 7262 mutex_lock(&priv->action_mutex);
7263 if (!(priv->status & STATUS_INITIALIZED)) { 7263 if (!(priv->status & STATUS_INITIALIZED)) {
7264 err = -EIO; 7264 err = -EIO;
7265 goto done; 7265 goto done;
7266 } 7266 }
7267 7267
7268 if (wrqu->rts.disabled) 7268 if (wrqu->rts.disabled)
7269 value = priv->rts_threshold | RTS_DISABLED; 7269 value = priv->rts_threshold | RTS_DISABLED;
7270 else { 7270 else {
7271 if (wrqu->rts.value < 1 || wrqu->rts.value > 2304) { 7271 if (wrqu->rts.value < 1 || wrqu->rts.value > 2304) {
7272 err = -EINVAL; 7272 err = -EINVAL;
7273 goto done; 7273 goto done;
7274 } 7274 }
7275 value = wrqu->rts.value; 7275 value = wrqu->rts.value;
7276 } 7276 }
7277 7277
7278 err = ipw2100_set_rts_threshold(priv, value); 7278 err = ipw2100_set_rts_threshold(priv, value);
7279 7279
7280 IPW_DEBUG_WX("SET RTS Threshold -> 0x%08X\n", value); 7280 IPW_DEBUG_WX("SET RTS Threshold -> 0x%08X\n", value);
7281 done: 7281 done:
7282 mutex_unlock(&priv->action_mutex); 7282 mutex_unlock(&priv->action_mutex);
7283 return err; 7283 return err;
7284 } 7284 }
7285 7285
7286 static int ipw2100_wx_get_rts(struct net_device *dev, 7286 static int ipw2100_wx_get_rts(struct net_device *dev,
7287 struct iw_request_info *info, 7287 struct iw_request_info *info,
7288 union iwreq_data *wrqu, char *extra) 7288 union iwreq_data *wrqu, char *extra)
7289 { 7289 {
7290 /* 7290 /*
7291 * This can be called at any time. No action lock required 7291 * This can be called at any time. No action lock required
7292 */ 7292 */
7293 7293
7294 struct ipw2100_priv *priv = libipw_priv(dev); 7294 struct ipw2100_priv *priv = libipw_priv(dev);
7295 7295
7296 wrqu->rts.value = priv->rts_threshold & ~RTS_DISABLED; 7296 wrqu->rts.value = priv->rts_threshold & ~RTS_DISABLED;
7297 wrqu->rts.fixed = 1; /* no auto select */ 7297 wrqu->rts.fixed = 1; /* no auto select */
7298 7298
7299 /* If RTS is set to the default value, then it is disabled */ 7299 /* If RTS is set to the default value, then it is disabled */
7300 wrqu->rts.disabled = (priv->rts_threshold & RTS_DISABLED) ? 1 : 0; 7300 wrqu->rts.disabled = (priv->rts_threshold & RTS_DISABLED) ? 1 : 0;
7301 7301
7302 IPW_DEBUG_WX("GET RTS Threshold -> 0x%08X\n", wrqu->rts.value); 7302 IPW_DEBUG_WX("GET RTS Threshold -> 0x%08X\n", wrqu->rts.value);
7303 7303
7304 return 0; 7304 return 0;
7305 } 7305 }
7306 7306
7307 static int ipw2100_wx_set_txpow(struct net_device *dev, 7307 static int ipw2100_wx_set_txpow(struct net_device *dev,
7308 struct iw_request_info *info, 7308 struct iw_request_info *info,
7309 union iwreq_data *wrqu, char *extra) 7309 union iwreq_data *wrqu, char *extra)
7310 { 7310 {
7311 struct ipw2100_priv *priv = libipw_priv(dev); 7311 struct ipw2100_priv *priv = libipw_priv(dev);
7312 int err = 0, value; 7312 int err = 0, value;
7313 7313
7314 if (ipw_radio_kill_sw(priv, wrqu->txpower.disabled)) 7314 if (ipw_radio_kill_sw(priv, wrqu->txpower.disabled))
7315 return -EINPROGRESS; 7315 return -EINPROGRESS;
7316 7316
7317 if (priv->ieee->iw_mode != IW_MODE_ADHOC) 7317 if (priv->ieee->iw_mode != IW_MODE_ADHOC)
7318 return 0; 7318 return 0;
7319 7319
7320 if ((wrqu->txpower.flags & IW_TXPOW_TYPE) != IW_TXPOW_DBM) 7320 if ((wrqu->txpower.flags & IW_TXPOW_TYPE) != IW_TXPOW_DBM)
7321 return -EINVAL; 7321 return -EINVAL;
7322 7322
7323 if (wrqu->txpower.fixed == 0) 7323 if (wrqu->txpower.fixed == 0)
7324 value = IPW_TX_POWER_DEFAULT; 7324 value = IPW_TX_POWER_DEFAULT;
7325 else { 7325 else {
7326 if (wrqu->txpower.value < IPW_TX_POWER_MIN_DBM || 7326 if (wrqu->txpower.value < IPW_TX_POWER_MIN_DBM ||
7327 wrqu->txpower.value > IPW_TX_POWER_MAX_DBM) 7327 wrqu->txpower.value > IPW_TX_POWER_MAX_DBM)
7328 return -EINVAL; 7328 return -EINVAL;
7329 7329
7330 value = wrqu->txpower.value; 7330 value = wrqu->txpower.value;
7331 } 7331 }
7332 7332
7333 mutex_lock(&priv->action_mutex); 7333 mutex_lock(&priv->action_mutex);
7334 if (!(priv->status & STATUS_INITIALIZED)) { 7334 if (!(priv->status & STATUS_INITIALIZED)) {
7335 err = -EIO; 7335 err = -EIO;
7336 goto done; 7336 goto done;
7337 } 7337 }
7338 7338
7339 err = ipw2100_set_tx_power(priv, value); 7339 err = ipw2100_set_tx_power(priv, value);
7340 7340
7341 IPW_DEBUG_WX("SET TX Power -> %d\n", value); 7341 IPW_DEBUG_WX("SET TX Power -> %d\n", value);
7342 7342
7343 done: 7343 done:
7344 mutex_unlock(&priv->action_mutex); 7344 mutex_unlock(&priv->action_mutex);
7345 return err; 7345 return err;
7346 } 7346 }
7347 7347
7348 static int ipw2100_wx_get_txpow(struct net_device *dev, 7348 static int ipw2100_wx_get_txpow(struct net_device *dev,
7349 struct iw_request_info *info, 7349 struct iw_request_info *info,
7350 union iwreq_data *wrqu, char *extra) 7350 union iwreq_data *wrqu, char *extra)
7351 { 7351 {
7352 /* 7352 /*
7353 * This can be called at any time. No action lock required 7353 * This can be called at any time. No action lock required
7354 */ 7354 */
7355 7355
7356 struct ipw2100_priv *priv = libipw_priv(dev); 7356 struct ipw2100_priv *priv = libipw_priv(dev);
7357 7357
7358 wrqu->txpower.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0; 7358 wrqu->txpower.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
7359 7359
7360 if (priv->tx_power == IPW_TX_POWER_DEFAULT) { 7360 if (priv->tx_power == IPW_TX_POWER_DEFAULT) {
7361 wrqu->txpower.fixed = 0; 7361 wrqu->txpower.fixed = 0;
7362 wrqu->txpower.value = IPW_TX_POWER_MAX_DBM; 7362 wrqu->txpower.value = IPW_TX_POWER_MAX_DBM;
7363 } else { 7363 } else {
7364 wrqu->txpower.fixed = 1; 7364 wrqu->txpower.fixed = 1;
7365 wrqu->txpower.value = priv->tx_power; 7365 wrqu->txpower.value = priv->tx_power;
7366 } 7366 }
7367 7367
7368 wrqu->txpower.flags = IW_TXPOW_DBM; 7368 wrqu->txpower.flags = IW_TXPOW_DBM;
7369 7369
7370 IPW_DEBUG_WX("GET TX Power -> %d\n", wrqu->txpower.value); 7370 IPW_DEBUG_WX("GET TX Power -> %d\n", wrqu->txpower.value);
7371 7371
7372 return 0; 7372 return 0;
7373 } 7373 }
7374 7374
7375 static int ipw2100_wx_set_frag(struct net_device *dev, 7375 static int ipw2100_wx_set_frag(struct net_device *dev,
7376 struct iw_request_info *info, 7376 struct iw_request_info *info,
7377 union iwreq_data *wrqu, char *extra) 7377 union iwreq_data *wrqu, char *extra)
7378 { 7378 {
7379 /* 7379 /*
7380 * This can be called at any time. No action lock required 7380 * This can be called at any time. No action lock required
7381 */ 7381 */
7382 7382
7383 struct ipw2100_priv *priv = libipw_priv(dev); 7383 struct ipw2100_priv *priv = libipw_priv(dev);
7384 7384
7385 if (!wrqu->frag.fixed) 7385 if (!wrqu->frag.fixed)
7386 return -EINVAL; 7386 return -EINVAL;
7387 7387
7388 if (wrqu->frag.disabled) { 7388 if (wrqu->frag.disabled) {
7389 priv->frag_threshold |= FRAG_DISABLED; 7389 priv->frag_threshold |= FRAG_DISABLED;
7390 priv->ieee->fts = DEFAULT_FTS; 7390 priv->ieee->fts = DEFAULT_FTS;
7391 } else { 7391 } else {
7392 if (wrqu->frag.value < MIN_FRAG_THRESHOLD || 7392 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
7393 wrqu->frag.value > MAX_FRAG_THRESHOLD) 7393 wrqu->frag.value > MAX_FRAG_THRESHOLD)
7394 return -EINVAL; 7394 return -EINVAL;
7395 7395
7396 priv->ieee->fts = wrqu->frag.value & ~0x1; 7396 priv->ieee->fts = wrqu->frag.value & ~0x1;
7397 priv->frag_threshold = priv->ieee->fts; 7397 priv->frag_threshold = priv->ieee->fts;
7398 } 7398 }
7399 7399
7400 IPW_DEBUG_WX("SET Frag Threshold -> %d\n", priv->ieee->fts); 7400 IPW_DEBUG_WX("SET Frag Threshold -> %d\n", priv->ieee->fts);
7401 7401
7402 return 0; 7402 return 0;
7403 } 7403 }
7404 7404
7405 static int ipw2100_wx_get_frag(struct net_device *dev, 7405 static int ipw2100_wx_get_frag(struct net_device *dev,
7406 struct iw_request_info *info, 7406 struct iw_request_info *info,
7407 union iwreq_data *wrqu, char *extra) 7407 union iwreq_data *wrqu, char *extra)
7408 { 7408 {
7409 /* 7409 /*
7410 * This can be called at any time. No action lock required 7410 * This can be called at any time. No action lock required
7411 */ 7411 */
7412 7412
7413 struct ipw2100_priv *priv = libipw_priv(dev); 7413 struct ipw2100_priv *priv = libipw_priv(dev);
7414 wrqu->frag.value = priv->frag_threshold & ~FRAG_DISABLED; 7414 wrqu->frag.value = priv->frag_threshold & ~FRAG_DISABLED;
7415 wrqu->frag.fixed = 0; /* no auto select */ 7415 wrqu->frag.fixed = 0; /* no auto select */
7416 wrqu->frag.disabled = (priv->frag_threshold & FRAG_DISABLED) ? 1 : 0; 7416 wrqu->frag.disabled = (priv->frag_threshold & FRAG_DISABLED) ? 1 : 0;
7417 7417
7418 IPW_DEBUG_WX("GET Frag Threshold -> %d\n", wrqu->frag.value); 7418 IPW_DEBUG_WX("GET Frag Threshold -> %d\n", wrqu->frag.value);
7419 7419
7420 return 0; 7420 return 0;
7421 } 7421 }
7422 7422
7423 static int ipw2100_wx_set_retry(struct net_device *dev, 7423 static int ipw2100_wx_set_retry(struct net_device *dev,
7424 struct iw_request_info *info, 7424 struct iw_request_info *info,
7425 union iwreq_data *wrqu, char *extra) 7425 union iwreq_data *wrqu, char *extra)
7426 { 7426 {
7427 struct ipw2100_priv *priv = libipw_priv(dev); 7427 struct ipw2100_priv *priv = libipw_priv(dev);
7428 int err = 0; 7428 int err = 0;
7429 7429
7430 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled) 7430 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
7431 return -EINVAL; 7431 return -EINVAL;
7432 7432
7433 if (!(wrqu->retry.flags & IW_RETRY_LIMIT)) 7433 if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
7434 return 0; 7434 return 0;
7435 7435
7436 mutex_lock(&priv->action_mutex); 7436 mutex_lock(&priv->action_mutex);
7437 if (!(priv->status & STATUS_INITIALIZED)) { 7437 if (!(priv->status & STATUS_INITIALIZED)) {
7438 err = -EIO; 7438 err = -EIO;
7439 goto done; 7439 goto done;
7440 } 7440 }
7441 7441
7442 if (wrqu->retry.flags & IW_RETRY_SHORT) { 7442 if (wrqu->retry.flags & IW_RETRY_SHORT) {
7443 err = ipw2100_set_short_retry(priv, wrqu->retry.value); 7443 err = ipw2100_set_short_retry(priv, wrqu->retry.value);
7444 IPW_DEBUG_WX("SET Short Retry Limit -> %d\n", 7444 IPW_DEBUG_WX("SET Short Retry Limit -> %d\n",
7445 wrqu->retry.value); 7445 wrqu->retry.value);
7446 goto done; 7446 goto done;
7447 } 7447 }
7448 7448
7449 if (wrqu->retry.flags & IW_RETRY_LONG) { 7449 if (wrqu->retry.flags & IW_RETRY_LONG) {
7450 err = ipw2100_set_long_retry(priv, wrqu->retry.value); 7450 err = ipw2100_set_long_retry(priv, wrqu->retry.value);
7451 IPW_DEBUG_WX("SET Long Retry Limit -> %d\n", 7451 IPW_DEBUG_WX("SET Long Retry Limit -> %d\n",
7452 wrqu->retry.value); 7452 wrqu->retry.value);
7453 goto done; 7453 goto done;
7454 } 7454 }
7455 7455
7456 err = ipw2100_set_short_retry(priv, wrqu->retry.value); 7456 err = ipw2100_set_short_retry(priv, wrqu->retry.value);
7457 if (!err) 7457 if (!err)
7458 err = ipw2100_set_long_retry(priv, wrqu->retry.value); 7458 err = ipw2100_set_long_retry(priv, wrqu->retry.value);
7459 7459
7460 IPW_DEBUG_WX("SET Both Retry Limits -> %d\n", wrqu->retry.value); 7460 IPW_DEBUG_WX("SET Both Retry Limits -> %d\n", wrqu->retry.value);
7461 7461
7462 done: 7462 done:
7463 mutex_unlock(&priv->action_mutex); 7463 mutex_unlock(&priv->action_mutex);
7464 return err; 7464 return err;
7465 } 7465 }
7466 7466
7467 static int ipw2100_wx_get_retry(struct net_device *dev, 7467 static int ipw2100_wx_get_retry(struct net_device *dev,
7468 struct iw_request_info *info, 7468 struct iw_request_info *info,
7469 union iwreq_data *wrqu, char *extra) 7469 union iwreq_data *wrqu, char *extra)
7470 { 7470 {
7471 /* 7471 /*
7472 * This can be called at any time. No action lock required 7472 * This can be called at any time. No action lock required
7473 */ 7473 */
7474 7474
7475 struct ipw2100_priv *priv = libipw_priv(dev); 7475 struct ipw2100_priv *priv = libipw_priv(dev);
7476 7476
7477 wrqu->retry.disabled = 0; /* can't be disabled */ 7477 wrqu->retry.disabled = 0; /* can't be disabled */
7478 7478
7479 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) 7479 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME)
7480 return -EINVAL; 7480 return -EINVAL;
7481 7481
7482 if (wrqu->retry.flags & IW_RETRY_LONG) { 7482 if (wrqu->retry.flags & IW_RETRY_LONG) {
7483 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_LONG; 7483 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
7484 wrqu->retry.value = priv->long_retry_limit; 7484 wrqu->retry.value = priv->long_retry_limit;
7485 } else { 7485 } else {
7486 wrqu->retry.flags = 7486 wrqu->retry.flags =
7487 (priv->short_retry_limit != 7487 (priv->short_retry_limit !=
7488 priv->long_retry_limit) ? 7488 priv->long_retry_limit) ?
7489 IW_RETRY_LIMIT | IW_RETRY_SHORT : IW_RETRY_LIMIT; 7489 IW_RETRY_LIMIT | IW_RETRY_SHORT : IW_RETRY_LIMIT;
7490 7490
7491 wrqu->retry.value = priv->short_retry_limit; 7491 wrqu->retry.value = priv->short_retry_limit;
7492 } 7492 }
7493 7493
7494 IPW_DEBUG_WX("GET Retry -> %d\n", wrqu->retry.value); 7494 IPW_DEBUG_WX("GET Retry -> %d\n", wrqu->retry.value);
7495 7495
7496 return 0; 7496 return 0;
7497 } 7497 }
7498 7498
7499 static int ipw2100_wx_set_scan(struct net_device *dev, 7499 static int ipw2100_wx_set_scan(struct net_device *dev,
7500 struct iw_request_info *info, 7500 struct iw_request_info *info,
7501 union iwreq_data *wrqu, char *extra) 7501 union iwreq_data *wrqu, char *extra)
7502 { 7502 {
7503 struct ipw2100_priv *priv = libipw_priv(dev); 7503 struct ipw2100_priv *priv = libipw_priv(dev);
7504 int err = 0; 7504 int err = 0;
7505 7505
7506 mutex_lock(&priv->action_mutex); 7506 mutex_lock(&priv->action_mutex);
7507 if (!(priv->status & STATUS_INITIALIZED)) { 7507 if (!(priv->status & STATUS_INITIALIZED)) {
7508 err = -EIO; 7508 err = -EIO;
7509 goto done; 7509 goto done;
7510 } 7510 }
7511 7511
7512 IPW_DEBUG_WX("Initiating scan...\n"); 7512 IPW_DEBUG_WX("Initiating scan...\n");
7513 7513
7514 priv->user_requested_scan = 1; 7514 priv->user_requested_scan = 1;
7515 if (ipw2100_set_scan_options(priv) || ipw2100_start_scan(priv)) { 7515 if (ipw2100_set_scan_options(priv) || ipw2100_start_scan(priv)) {
7516 IPW_DEBUG_WX("Start scan failed.\n"); 7516 IPW_DEBUG_WX("Start scan failed.\n");
7517 7517
7518 /* TODO: Mark a scan as pending so when hardware initialized 7518 /* TODO: Mark a scan as pending so when hardware initialized
7519 * a scan starts */ 7519 * a scan starts */
7520 } 7520 }
7521 7521
7522 done: 7522 done:
7523 mutex_unlock(&priv->action_mutex); 7523 mutex_unlock(&priv->action_mutex);
7524 return err; 7524 return err;
7525 } 7525 }
7526 7526
7527 static int ipw2100_wx_get_scan(struct net_device *dev, 7527 static int ipw2100_wx_get_scan(struct net_device *dev,
7528 struct iw_request_info *info, 7528 struct iw_request_info *info,
7529 union iwreq_data *wrqu, char *extra) 7529 union iwreq_data *wrqu, char *extra)
7530 { 7530 {
7531 /* 7531 /*
7532 * This can be called at any time. No action lock required 7532 * This can be called at any time. No action lock required
7533 */ 7533 */
7534 7534
7535 struct ipw2100_priv *priv = libipw_priv(dev); 7535 struct ipw2100_priv *priv = libipw_priv(dev);
7536 return libipw_wx_get_scan(priv->ieee, info, wrqu, extra); 7536 return libipw_wx_get_scan(priv->ieee, info, wrqu, extra);
7537 } 7537 }
7538 7538
7539 /* 7539 /*
7540 * Implementation based on code in hostap-driver v0.1.3 hostap_ioctl.c 7540 * Implementation based on code in hostap-driver v0.1.3 hostap_ioctl.c
7541 */ 7541 */
7542 static int ipw2100_wx_set_encode(struct net_device *dev, 7542 static int ipw2100_wx_set_encode(struct net_device *dev,
7543 struct iw_request_info *info, 7543 struct iw_request_info *info,
7544 union iwreq_data *wrqu, char *key) 7544 union iwreq_data *wrqu, char *key)
7545 { 7545 {
7546 /* 7546 /*
7547 * No check of STATUS_INITIALIZED required 7547 * No check of STATUS_INITIALIZED required
7548 */ 7548 */
7549 7549
7550 struct ipw2100_priv *priv = libipw_priv(dev); 7550 struct ipw2100_priv *priv = libipw_priv(dev);
7551 return libipw_wx_set_encode(priv->ieee, info, wrqu, key); 7551 return libipw_wx_set_encode(priv->ieee, info, wrqu, key);
7552 } 7552 }
7553 7553
7554 static int ipw2100_wx_get_encode(struct net_device *dev, 7554 static int ipw2100_wx_get_encode(struct net_device *dev,
7555 struct iw_request_info *info, 7555 struct iw_request_info *info,
7556 union iwreq_data *wrqu, char *key) 7556 union iwreq_data *wrqu, char *key)
7557 { 7557 {
7558 /* 7558 /*
7559 * This can be called at any time. No action lock required 7559 * This can be called at any time. No action lock required
7560 */ 7560 */
7561 7561
7562 struct ipw2100_priv *priv = libipw_priv(dev); 7562 struct ipw2100_priv *priv = libipw_priv(dev);
7563 return libipw_wx_get_encode(priv->ieee, info, wrqu, key); 7563 return libipw_wx_get_encode(priv->ieee, info, wrqu, key);
7564 } 7564 }
7565 7565
7566 static int ipw2100_wx_set_power(struct net_device *dev, 7566 static int ipw2100_wx_set_power(struct net_device *dev,
7567 struct iw_request_info *info, 7567 struct iw_request_info *info,
7568 union iwreq_data *wrqu, char *extra) 7568 union iwreq_data *wrqu, char *extra)
7569 { 7569 {
7570 struct ipw2100_priv *priv = libipw_priv(dev); 7570 struct ipw2100_priv *priv = libipw_priv(dev);
7571 int err = 0; 7571 int err = 0;
7572 7572
7573 mutex_lock(&priv->action_mutex); 7573 mutex_lock(&priv->action_mutex);
7574 if (!(priv->status & STATUS_INITIALIZED)) { 7574 if (!(priv->status & STATUS_INITIALIZED)) {
7575 err = -EIO; 7575 err = -EIO;
7576 goto done; 7576 goto done;
7577 } 7577 }
7578 7578
7579 if (wrqu->power.disabled) { 7579 if (wrqu->power.disabled) {
7580 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode); 7580 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
7581 err = ipw2100_set_power_mode(priv, IPW_POWER_MODE_CAM); 7581 err = ipw2100_set_power_mode(priv, IPW_POWER_MODE_CAM);
7582 IPW_DEBUG_WX("SET Power Management Mode -> off\n"); 7582 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
7583 goto done; 7583 goto done;
7584 } 7584 }
7585 7585
7586 switch (wrqu->power.flags & IW_POWER_MODE) { 7586 switch (wrqu->power.flags & IW_POWER_MODE) {
7587 case IW_POWER_ON: /* If not specified */ 7587 case IW_POWER_ON: /* If not specified */
7588 case IW_POWER_MODE: /* If set all mask */ 7588 case IW_POWER_MODE: /* If set all mask */
7589 case IW_POWER_ALL_R: /* If explicitly state all */ 7589 case IW_POWER_ALL_R: /* If explicitly state all */
7590 break; 7590 break;
7591 default: /* Otherwise we don't support it */ 7591 default: /* Otherwise we don't support it */
7592 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n", 7592 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
7593 wrqu->power.flags); 7593 wrqu->power.flags);
7594 err = -EOPNOTSUPP; 7594 err = -EOPNOTSUPP;
7595 goto done; 7595 goto done;
7596 } 7596 }
7597 7597
7598 /* If the user hasn't specified a power management mode yet, default 7598 /* If the user hasn't specified a power management mode yet, default
7599 * to BATTERY */ 7599 * to BATTERY */
7600 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode; 7600 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
7601 err = ipw2100_set_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode)); 7601 err = ipw2100_set_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
7602 7602
7603 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode); 7603 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
7604 7604
7605 done: 7605 done:
7606 mutex_unlock(&priv->action_mutex); 7606 mutex_unlock(&priv->action_mutex);
7607 return err; 7607 return err;
7608 7608
7609 } 7609 }
7610 7610
7611 static int ipw2100_wx_get_power(struct net_device *dev, 7611 static int ipw2100_wx_get_power(struct net_device *dev,
7612 struct iw_request_info *info, 7612 struct iw_request_info *info,
7613 union iwreq_data *wrqu, char *extra) 7613 union iwreq_data *wrqu, char *extra)
7614 { 7614 {
7615 /* 7615 /*
7616 * This can be called at any time. No action lock required 7616 * This can be called at any time. No action lock required
7617 */ 7617 */
7618 7618
7619 struct ipw2100_priv *priv = libipw_priv(dev); 7619 struct ipw2100_priv *priv = libipw_priv(dev);
7620 7620
7621 if (!(priv->power_mode & IPW_POWER_ENABLED)) 7621 if (!(priv->power_mode & IPW_POWER_ENABLED))
7622 wrqu->power.disabled = 1; 7622 wrqu->power.disabled = 1;
7623 else { 7623 else {
7624 wrqu->power.disabled = 0; 7624 wrqu->power.disabled = 0;
7625 wrqu->power.flags = 0; 7625 wrqu->power.flags = 0;
7626 } 7626 }
7627 7627
7628 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode); 7628 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
7629 7629
7630 return 0; 7630 return 0;
7631 } 7631 }
7632 7632
7633 /* 7633 /*
7634 * WE-18 WPA support 7634 * WE-18 WPA support
7635 */ 7635 */
7636 7636
7637 /* SIOCSIWGENIE */ 7637 /* SIOCSIWGENIE */
7638 static int ipw2100_wx_set_genie(struct net_device *dev, 7638 static int ipw2100_wx_set_genie(struct net_device *dev,
7639 struct iw_request_info *info, 7639 struct iw_request_info *info,
7640 union iwreq_data *wrqu, char *extra) 7640 union iwreq_data *wrqu, char *extra)
7641 { 7641 {
7642 7642
7643 struct ipw2100_priv *priv = libipw_priv(dev); 7643 struct ipw2100_priv *priv = libipw_priv(dev);
7644 struct libipw_device *ieee = priv->ieee; 7644 struct libipw_device *ieee = priv->ieee;
7645 u8 *buf; 7645 u8 *buf;
7646 7646
7647 if (!ieee->wpa_enabled) 7647 if (!ieee->wpa_enabled)
7648 return -EOPNOTSUPP; 7648 return -EOPNOTSUPP;
7649 7649
7650 if (wrqu->data.length > MAX_WPA_IE_LEN || 7650 if (wrqu->data.length > MAX_WPA_IE_LEN ||
7651 (wrqu->data.length && extra == NULL)) 7651 (wrqu->data.length && extra == NULL))
7652 return -EINVAL; 7652 return -EINVAL;
7653 7653
7654 if (wrqu->data.length) { 7654 if (wrqu->data.length) {
7655 buf = kmemdup(extra, wrqu->data.length, GFP_KERNEL); 7655 buf = kmemdup(extra, wrqu->data.length, GFP_KERNEL);
7656 if (buf == NULL) 7656 if (buf == NULL)
7657 return -ENOMEM; 7657 return -ENOMEM;
7658 7658
7659 kfree(ieee->wpa_ie); 7659 kfree(ieee->wpa_ie);
7660 ieee->wpa_ie = buf; 7660 ieee->wpa_ie = buf;
7661 ieee->wpa_ie_len = wrqu->data.length; 7661 ieee->wpa_ie_len = wrqu->data.length;
7662 } else { 7662 } else {
7663 kfree(ieee->wpa_ie); 7663 kfree(ieee->wpa_ie);
7664 ieee->wpa_ie = NULL; 7664 ieee->wpa_ie = NULL;
7665 ieee->wpa_ie_len = 0; 7665 ieee->wpa_ie_len = 0;
7666 } 7666 }
7667 7667
7668 ipw2100_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len); 7668 ipw2100_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
7669 7669
7670 return 0; 7670 return 0;
7671 } 7671 }
7672 7672
7673 /* SIOCGIWGENIE */ 7673 /* SIOCGIWGENIE */
7674 static int ipw2100_wx_get_genie(struct net_device *dev, 7674 static int ipw2100_wx_get_genie(struct net_device *dev,
7675 struct iw_request_info *info, 7675 struct iw_request_info *info,
7676 union iwreq_data *wrqu, char *extra) 7676 union iwreq_data *wrqu, char *extra)
7677 { 7677 {
7678 struct ipw2100_priv *priv = libipw_priv(dev); 7678 struct ipw2100_priv *priv = libipw_priv(dev);
7679 struct libipw_device *ieee = priv->ieee; 7679 struct libipw_device *ieee = priv->ieee;
7680 7680
7681 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) { 7681 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
7682 wrqu->data.length = 0; 7682 wrqu->data.length = 0;
7683 return 0; 7683 return 0;
7684 } 7684 }
7685 7685
7686 if (wrqu->data.length < ieee->wpa_ie_len) 7686 if (wrqu->data.length < ieee->wpa_ie_len)
7687 return -E2BIG; 7687 return -E2BIG;
7688 7688
7689 wrqu->data.length = ieee->wpa_ie_len; 7689 wrqu->data.length = ieee->wpa_ie_len;
7690 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len); 7690 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
7691 7691
7692 return 0; 7692 return 0;
7693 } 7693 }
7694 7694
7695 /* SIOCSIWAUTH */ 7695 /* SIOCSIWAUTH */
7696 static int ipw2100_wx_set_auth(struct net_device *dev, 7696 static int ipw2100_wx_set_auth(struct net_device *dev,
7697 struct iw_request_info *info, 7697 struct iw_request_info *info,
7698 union iwreq_data *wrqu, char *extra) 7698 union iwreq_data *wrqu, char *extra)
7699 { 7699 {
7700 struct ipw2100_priv *priv = libipw_priv(dev); 7700 struct ipw2100_priv *priv = libipw_priv(dev);
7701 struct libipw_device *ieee = priv->ieee; 7701 struct libipw_device *ieee = priv->ieee;
7702 struct iw_param *param = &wrqu->param; 7702 struct iw_param *param = &wrqu->param;
7703 struct lib80211_crypt_data *crypt; 7703 struct lib80211_crypt_data *crypt;
7704 unsigned long flags; 7704 unsigned long flags;
7705 int ret = 0; 7705 int ret = 0;
7706 7706
7707 switch (param->flags & IW_AUTH_INDEX) { 7707 switch (param->flags & IW_AUTH_INDEX) {
7708 case IW_AUTH_WPA_VERSION: 7708 case IW_AUTH_WPA_VERSION:
7709 case IW_AUTH_CIPHER_PAIRWISE: 7709 case IW_AUTH_CIPHER_PAIRWISE:
7710 case IW_AUTH_CIPHER_GROUP: 7710 case IW_AUTH_CIPHER_GROUP:
7711 case IW_AUTH_KEY_MGMT: 7711 case IW_AUTH_KEY_MGMT:
7712 /* 7712 /*
7713 * ipw2200 does not use these parameters 7713 * ipw2200 does not use these parameters
7714 */ 7714 */
7715 break; 7715 break;
7716 7716
7717 case IW_AUTH_TKIP_COUNTERMEASURES: 7717 case IW_AUTH_TKIP_COUNTERMEASURES:
7718 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx]; 7718 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
7719 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags) 7719 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
7720 break; 7720 break;
7721 7721
7722 flags = crypt->ops->get_flags(crypt->priv); 7722 flags = crypt->ops->get_flags(crypt->priv);
7723 7723
7724 if (param->value) 7724 if (param->value)
7725 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES; 7725 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
7726 else 7726 else
7727 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES; 7727 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
7728 7728
7729 crypt->ops->set_flags(flags, crypt->priv); 7729 crypt->ops->set_flags(flags, crypt->priv);
7730 7730
7731 break; 7731 break;
7732 7732
7733 case IW_AUTH_DROP_UNENCRYPTED:{ 7733 case IW_AUTH_DROP_UNENCRYPTED:{
7734 /* HACK: 7734 /* HACK:
7735 * 7735 *
7736 * wpa_supplicant calls set_wpa_enabled when the driver 7736 * wpa_supplicant calls set_wpa_enabled when the driver
7737 * is loaded and unloaded, regardless of if WPA is being 7737 * is loaded and unloaded, regardless of if WPA is being
7738 * used. No other calls are made which can be used to 7738 * used. No other calls are made which can be used to
7739 * determine if encryption will be used or not prior to 7739 * determine if encryption will be used or not prior to
7740 * association being expected. If encryption is not being 7740 * association being expected. If encryption is not being
7741 * used, drop_unencrypted is set to false, else true -- we 7741 * used, drop_unencrypted is set to false, else true -- we
7742 * can use this to determine if the CAP_PRIVACY_ON bit should 7742 * can use this to determine if the CAP_PRIVACY_ON bit should
7743 * be set. 7743 * be set.
7744 */ 7744 */
7745 struct libipw_security sec = { 7745 struct libipw_security sec = {
7746 .flags = SEC_ENABLED, 7746 .flags = SEC_ENABLED,
7747 .enabled = param->value, 7747 .enabled = param->value,
7748 }; 7748 };
7749 priv->ieee->drop_unencrypted = param->value; 7749 priv->ieee->drop_unencrypted = param->value;
7750 /* We only change SEC_LEVEL for open mode. Others 7750 /* We only change SEC_LEVEL for open mode. Others
7751 * are set by ipw_wpa_set_encryption. 7751 * are set by ipw_wpa_set_encryption.
7752 */ 7752 */
7753 if (!param->value) { 7753 if (!param->value) {
7754 sec.flags |= SEC_LEVEL; 7754 sec.flags |= SEC_LEVEL;
7755 sec.level = SEC_LEVEL_0; 7755 sec.level = SEC_LEVEL_0;
7756 } else { 7756 } else {
7757 sec.flags |= SEC_LEVEL; 7757 sec.flags |= SEC_LEVEL;
7758 sec.level = SEC_LEVEL_1; 7758 sec.level = SEC_LEVEL_1;
7759 } 7759 }
7760 if (priv->ieee->set_security) 7760 if (priv->ieee->set_security)
7761 priv->ieee->set_security(priv->ieee->dev, &sec); 7761 priv->ieee->set_security(priv->ieee->dev, &sec);
7762 break; 7762 break;
7763 } 7763 }
7764 7764
7765 case IW_AUTH_80211_AUTH_ALG: 7765 case IW_AUTH_80211_AUTH_ALG:
7766 ret = ipw2100_wpa_set_auth_algs(priv, param->value); 7766 ret = ipw2100_wpa_set_auth_algs(priv, param->value);
7767 break; 7767 break;
7768 7768
7769 case IW_AUTH_WPA_ENABLED: 7769 case IW_AUTH_WPA_ENABLED:
7770 ret = ipw2100_wpa_enable(priv, param->value); 7770 ret = ipw2100_wpa_enable(priv, param->value);
7771 break; 7771 break;
7772 7772
7773 case IW_AUTH_RX_UNENCRYPTED_EAPOL: 7773 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
7774 ieee->ieee802_1x = param->value; 7774 ieee->ieee802_1x = param->value;
7775 break; 7775 break;
7776 7776
7777 //case IW_AUTH_ROAMING_CONTROL: 7777 //case IW_AUTH_ROAMING_CONTROL:
7778 case IW_AUTH_PRIVACY_INVOKED: 7778 case IW_AUTH_PRIVACY_INVOKED:
7779 ieee->privacy_invoked = param->value; 7779 ieee->privacy_invoked = param->value;
7780 break; 7780 break;
7781 7781
7782 default: 7782 default:
7783 return -EOPNOTSUPP; 7783 return -EOPNOTSUPP;
7784 } 7784 }
7785 return ret; 7785 return ret;
7786 } 7786 }
7787 7787
7788 /* SIOCGIWAUTH */ 7788 /* SIOCGIWAUTH */
7789 static int ipw2100_wx_get_auth(struct net_device *dev, 7789 static int ipw2100_wx_get_auth(struct net_device *dev,
7790 struct iw_request_info *info, 7790 struct iw_request_info *info,
7791 union iwreq_data *wrqu, char *extra) 7791 union iwreq_data *wrqu, char *extra)
7792 { 7792 {
7793 struct ipw2100_priv *priv = libipw_priv(dev); 7793 struct ipw2100_priv *priv = libipw_priv(dev);
7794 struct libipw_device *ieee = priv->ieee; 7794 struct libipw_device *ieee = priv->ieee;
7795 struct lib80211_crypt_data *crypt; 7795 struct lib80211_crypt_data *crypt;
7796 struct iw_param *param = &wrqu->param; 7796 struct iw_param *param = &wrqu->param;
7797 int ret = 0; 7797 int ret = 0;
7798 7798
7799 switch (param->flags & IW_AUTH_INDEX) { 7799 switch (param->flags & IW_AUTH_INDEX) {
7800 case IW_AUTH_WPA_VERSION: 7800 case IW_AUTH_WPA_VERSION:
7801 case IW_AUTH_CIPHER_PAIRWISE: 7801 case IW_AUTH_CIPHER_PAIRWISE:
7802 case IW_AUTH_CIPHER_GROUP: 7802 case IW_AUTH_CIPHER_GROUP:
7803 case IW_AUTH_KEY_MGMT: 7803 case IW_AUTH_KEY_MGMT:
7804 /* 7804 /*
7805 * wpa_supplicant will control these internally 7805 * wpa_supplicant will control these internally
7806 */ 7806 */
7807 ret = -EOPNOTSUPP; 7807 ret = -EOPNOTSUPP;
7808 break; 7808 break;
7809 7809
7810 case IW_AUTH_TKIP_COUNTERMEASURES: 7810 case IW_AUTH_TKIP_COUNTERMEASURES:
7811 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx]; 7811 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
7812 if (!crypt || !crypt->ops->get_flags) { 7812 if (!crypt || !crypt->ops->get_flags) {
7813 IPW_DEBUG_WARNING("Can't get TKIP countermeasures: " 7813 IPW_DEBUG_WARNING("Can't get TKIP countermeasures: "
7814 "crypt not set!\n"); 7814 "crypt not set!\n");
7815 break; 7815 break;
7816 } 7816 }
7817 7817
7818 param->value = (crypt->ops->get_flags(crypt->priv) & 7818 param->value = (crypt->ops->get_flags(crypt->priv) &
7819 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0; 7819 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
7820 7820
7821 break; 7821 break;
7822 7822
7823 case IW_AUTH_DROP_UNENCRYPTED: 7823 case IW_AUTH_DROP_UNENCRYPTED:
7824 param->value = ieee->drop_unencrypted; 7824 param->value = ieee->drop_unencrypted;
7825 break; 7825 break;
7826 7826
7827 case IW_AUTH_80211_AUTH_ALG: 7827 case IW_AUTH_80211_AUTH_ALG:
7828 param->value = priv->ieee->sec.auth_mode; 7828 param->value = priv->ieee->sec.auth_mode;
7829 break; 7829 break;
7830 7830
7831 case IW_AUTH_WPA_ENABLED: 7831 case IW_AUTH_WPA_ENABLED:
7832 param->value = ieee->wpa_enabled; 7832 param->value = ieee->wpa_enabled;
7833 break; 7833 break;
7834 7834
7835 case IW_AUTH_RX_UNENCRYPTED_EAPOL: 7835 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
7836 param->value = ieee->ieee802_1x; 7836 param->value = ieee->ieee802_1x;
7837 break; 7837 break;
7838 7838
7839 case IW_AUTH_ROAMING_CONTROL: 7839 case IW_AUTH_ROAMING_CONTROL:
7840 case IW_AUTH_PRIVACY_INVOKED: 7840 case IW_AUTH_PRIVACY_INVOKED:
7841 param->value = ieee->privacy_invoked; 7841 param->value = ieee->privacy_invoked;
7842 break; 7842 break;
7843 7843
7844 default: 7844 default:
7845 return -EOPNOTSUPP; 7845 return -EOPNOTSUPP;
7846 } 7846 }
7847 return 0; 7847 return 0;
7848 } 7848 }
7849 7849
7850 /* SIOCSIWENCODEEXT */ 7850 /* SIOCSIWENCODEEXT */
7851 static int ipw2100_wx_set_encodeext(struct net_device *dev, 7851 static int ipw2100_wx_set_encodeext(struct net_device *dev,
7852 struct iw_request_info *info, 7852 struct iw_request_info *info,
7853 union iwreq_data *wrqu, char *extra) 7853 union iwreq_data *wrqu, char *extra)
7854 { 7854 {
7855 struct ipw2100_priv *priv = libipw_priv(dev); 7855 struct ipw2100_priv *priv = libipw_priv(dev);
7856 return libipw_wx_set_encodeext(priv->ieee, info, wrqu, extra); 7856 return libipw_wx_set_encodeext(priv->ieee, info, wrqu, extra);
7857 } 7857 }
7858 7858
7859 /* SIOCGIWENCODEEXT */ 7859 /* SIOCGIWENCODEEXT */
7860 static int ipw2100_wx_get_encodeext(struct net_device *dev, 7860 static int ipw2100_wx_get_encodeext(struct net_device *dev,
7861 struct iw_request_info *info, 7861 struct iw_request_info *info,
7862 union iwreq_data *wrqu, char *extra) 7862 union iwreq_data *wrqu, char *extra)
7863 { 7863 {
7864 struct ipw2100_priv *priv = libipw_priv(dev); 7864 struct ipw2100_priv *priv = libipw_priv(dev);
7865 return libipw_wx_get_encodeext(priv->ieee, info, wrqu, extra); 7865 return libipw_wx_get_encodeext(priv->ieee, info, wrqu, extra);
7866 } 7866 }
7867 7867
7868 /* SIOCSIWMLME */ 7868 /* SIOCSIWMLME */
7869 static int ipw2100_wx_set_mlme(struct net_device *dev, 7869 static int ipw2100_wx_set_mlme(struct net_device *dev,
7870 struct iw_request_info *info, 7870 struct iw_request_info *info,
7871 union iwreq_data *wrqu, char *extra) 7871 union iwreq_data *wrqu, char *extra)
7872 { 7872 {
7873 struct ipw2100_priv *priv = libipw_priv(dev); 7873 struct ipw2100_priv *priv = libipw_priv(dev);
7874 struct iw_mlme *mlme = (struct iw_mlme *)extra; 7874 struct iw_mlme *mlme = (struct iw_mlme *)extra;
7875 __le16 reason; 7875 __le16 reason;
7876 7876
7877 reason = cpu_to_le16(mlme->reason_code); 7877 reason = cpu_to_le16(mlme->reason_code);
7878 7878
7879 switch (mlme->cmd) { 7879 switch (mlme->cmd) {
7880 case IW_MLME_DEAUTH: 7880 case IW_MLME_DEAUTH:
7881 // silently ignore 7881 // silently ignore
7882 break; 7882 break;
7883 7883
7884 case IW_MLME_DISASSOC: 7884 case IW_MLME_DISASSOC:
7885 ipw2100_disassociate_bssid(priv); 7885 ipw2100_disassociate_bssid(priv);
7886 break; 7886 break;
7887 7887
7888 default: 7888 default:
7889 return -EOPNOTSUPP; 7889 return -EOPNOTSUPP;
7890 } 7890 }
7891 return 0; 7891 return 0;
7892 } 7892 }
7893 7893
7894 /* 7894 /*
7895 * 7895 *
7896 * IWPRIV handlers 7896 * IWPRIV handlers
7897 * 7897 *
7898 */ 7898 */
7899 #ifdef CONFIG_IPW2100_MONITOR 7899 #ifdef CONFIG_IPW2100_MONITOR
7900 static int ipw2100_wx_set_promisc(struct net_device *dev, 7900 static int ipw2100_wx_set_promisc(struct net_device *dev,
7901 struct iw_request_info *info, 7901 struct iw_request_info *info,
7902 union iwreq_data *wrqu, char *extra) 7902 union iwreq_data *wrqu, char *extra)
7903 { 7903 {
7904 struct ipw2100_priv *priv = libipw_priv(dev); 7904 struct ipw2100_priv *priv = libipw_priv(dev);
7905 int *parms = (int *)extra; 7905 int *parms = (int *)extra;
7906 int enable = (parms[0] > 0); 7906 int enable = (parms[0] > 0);
7907 int err = 0; 7907 int err = 0;
7908 7908
7909 mutex_lock(&priv->action_mutex); 7909 mutex_lock(&priv->action_mutex);
7910 if (!(priv->status & STATUS_INITIALIZED)) { 7910 if (!(priv->status & STATUS_INITIALIZED)) {
7911 err = -EIO; 7911 err = -EIO;
7912 goto done; 7912 goto done;
7913 } 7913 }
7914 7914
7915 if (enable) { 7915 if (enable) {
7916 if (priv->ieee->iw_mode == IW_MODE_MONITOR) { 7916 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7917 err = ipw2100_set_channel(priv, parms[1], 0); 7917 err = ipw2100_set_channel(priv, parms[1], 0);
7918 goto done; 7918 goto done;
7919 } 7919 }
7920 priv->channel = parms[1]; 7920 priv->channel = parms[1];
7921 err = ipw2100_switch_mode(priv, IW_MODE_MONITOR); 7921 err = ipw2100_switch_mode(priv, IW_MODE_MONITOR);
7922 } else { 7922 } else {
7923 if (priv->ieee->iw_mode == IW_MODE_MONITOR) 7923 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
7924 err = ipw2100_switch_mode(priv, priv->last_mode); 7924 err = ipw2100_switch_mode(priv, priv->last_mode);
7925 } 7925 }
7926 done: 7926 done:
7927 mutex_unlock(&priv->action_mutex); 7927 mutex_unlock(&priv->action_mutex);
7928 return err; 7928 return err;
7929 } 7929 }
7930 7930
7931 static int ipw2100_wx_reset(struct net_device *dev, 7931 static int ipw2100_wx_reset(struct net_device *dev,
7932 struct iw_request_info *info, 7932 struct iw_request_info *info,
7933 union iwreq_data *wrqu, char *extra) 7933 union iwreq_data *wrqu, char *extra)
7934 { 7934 {
7935 struct ipw2100_priv *priv = libipw_priv(dev); 7935 struct ipw2100_priv *priv = libipw_priv(dev);
7936 if (priv->status & STATUS_INITIALIZED) 7936 if (priv->status & STATUS_INITIALIZED)
7937 schedule_reset(priv); 7937 schedule_reset(priv);
7938 return 0; 7938 return 0;
7939 } 7939 }
7940 7940
7941 #endif 7941 #endif
7942 7942
7943 static int ipw2100_wx_set_powermode(struct net_device *dev, 7943 static int ipw2100_wx_set_powermode(struct net_device *dev,
7944 struct iw_request_info *info, 7944 struct iw_request_info *info,
7945 union iwreq_data *wrqu, char *extra) 7945 union iwreq_data *wrqu, char *extra)
7946 { 7946 {
7947 struct ipw2100_priv *priv = libipw_priv(dev); 7947 struct ipw2100_priv *priv = libipw_priv(dev);
7948 int err = 0, mode = *(int *)extra; 7948 int err = 0, mode = *(int *)extra;
7949 7949
7950 mutex_lock(&priv->action_mutex); 7950 mutex_lock(&priv->action_mutex);
7951 if (!(priv->status & STATUS_INITIALIZED)) { 7951 if (!(priv->status & STATUS_INITIALIZED)) {
7952 err = -EIO; 7952 err = -EIO;
7953 goto done; 7953 goto done;
7954 } 7954 }
7955 7955
7956 if ((mode < 0) || (mode > POWER_MODES)) 7956 if ((mode < 0) || (mode > POWER_MODES))
7957 mode = IPW_POWER_AUTO; 7957 mode = IPW_POWER_AUTO;
7958 7958
7959 if (IPW_POWER_LEVEL(priv->power_mode) != mode) 7959 if (IPW_POWER_LEVEL(priv->power_mode) != mode)
7960 err = ipw2100_set_power_mode(priv, mode); 7960 err = ipw2100_set_power_mode(priv, mode);
7961 done: 7961 done:
7962 mutex_unlock(&priv->action_mutex); 7962 mutex_unlock(&priv->action_mutex);
7963 return err; 7963 return err;
7964 } 7964 }
7965 7965
7966 #define MAX_POWER_STRING 80 7966 #define MAX_POWER_STRING 80
7967 static int ipw2100_wx_get_powermode(struct net_device *dev, 7967 static int ipw2100_wx_get_powermode(struct net_device *dev,
7968 struct iw_request_info *info, 7968 struct iw_request_info *info,
7969 union iwreq_data *wrqu, char *extra) 7969 union iwreq_data *wrqu, char *extra)
7970 { 7970 {
7971 /* 7971 /*
7972 * This can be called at any time. No action lock required 7972 * This can be called at any time. No action lock required
7973 */ 7973 */
7974 7974
7975 struct ipw2100_priv *priv = libipw_priv(dev); 7975 struct ipw2100_priv *priv = libipw_priv(dev);
7976 int level = IPW_POWER_LEVEL(priv->power_mode); 7976 int level = IPW_POWER_LEVEL(priv->power_mode);
7977 s32 timeout, period; 7977 s32 timeout, period;
7978 7978
7979 if (!(priv->power_mode & IPW_POWER_ENABLED)) { 7979 if (!(priv->power_mode & IPW_POWER_ENABLED)) {
7980 snprintf(extra, MAX_POWER_STRING, 7980 snprintf(extra, MAX_POWER_STRING,
7981 "Power save level: %d (Off)", level); 7981 "Power save level: %d (Off)", level);
7982 } else { 7982 } else {
7983 switch (level) { 7983 switch (level) {
7984 case IPW_POWER_MODE_CAM: 7984 case IPW_POWER_MODE_CAM:
7985 snprintf(extra, MAX_POWER_STRING, 7985 snprintf(extra, MAX_POWER_STRING,
7986 "Power save level: %d (None)", level); 7986 "Power save level: %d (None)", level);
7987 break; 7987 break;
7988 case IPW_POWER_AUTO: 7988 case IPW_POWER_AUTO:
7989 snprintf(extra, MAX_POWER_STRING, 7989 snprintf(extra, MAX_POWER_STRING,
7990 "Power save level: %d (Auto)", level); 7990 "Power save level: %d (Auto)", level);
7991 break; 7991 break;
7992 default: 7992 default:
7993 timeout = timeout_duration[level - 1] / 1000; 7993 timeout = timeout_duration[level - 1] / 1000;
7994 period = period_duration[level - 1] / 1000; 7994 period = period_duration[level - 1] / 1000;
7995 snprintf(extra, MAX_POWER_STRING, 7995 snprintf(extra, MAX_POWER_STRING,
7996 "Power save level: %d " 7996 "Power save level: %d "
7997 "(Timeout %dms, Period %dms)", 7997 "(Timeout %dms, Period %dms)",
7998 level, timeout, period); 7998 level, timeout, period);
7999 } 7999 }
8000 } 8000 }
8001 8001
8002 wrqu->data.length = strlen(extra) + 1; 8002 wrqu->data.length = strlen(extra) + 1;
8003 8003
8004 return 0; 8004 return 0;
8005 } 8005 }
8006 8006
8007 static int ipw2100_wx_set_preamble(struct net_device *dev, 8007 static int ipw2100_wx_set_preamble(struct net_device *dev,
8008 struct iw_request_info *info, 8008 struct iw_request_info *info,
8009 union iwreq_data *wrqu, char *extra) 8009 union iwreq_data *wrqu, char *extra)
8010 { 8010 {
8011 struct ipw2100_priv *priv = libipw_priv(dev); 8011 struct ipw2100_priv *priv = libipw_priv(dev);
8012 int err, mode = *(int *)extra; 8012 int err, mode = *(int *)extra;
8013 8013
8014 mutex_lock(&priv->action_mutex); 8014 mutex_lock(&priv->action_mutex);
8015 if (!(priv->status & STATUS_INITIALIZED)) { 8015 if (!(priv->status & STATUS_INITIALIZED)) {
8016 err = -EIO; 8016 err = -EIO;
8017 goto done; 8017 goto done;
8018 } 8018 }
8019 8019
8020 if (mode == 1) 8020 if (mode == 1)
8021 priv->config |= CFG_LONG_PREAMBLE; 8021 priv->config |= CFG_LONG_PREAMBLE;
8022 else if (mode == 0) 8022 else if (mode == 0)
8023 priv->config &= ~CFG_LONG_PREAMBLE; 8023 priv->config &= ~CFG_LONG_PREAMBLE;
8024 else { 8024 else {
8025 err = -EINVAL; 8025 err = -EINVAL;
8026 goto done; 8026 goto done;
8027 } 8027 }
8028 8028
8029 err = ipw2100_system_config(priv, 0); 8029 err = ipw2100_system_config(priv, 0);
8030 8030
8031 done: 8031 done:
8032 mutex_unlock(&priv->action_mutex); 8032 mutex_unlock(&priv->action_mutex);
8033 return err; 8033 return err;
8034 } 8034 }
8035 8035
8036 static int ipw2100_wx_get_preamble(struct net_device *dev, 8036 static int ipw2100_wx_get_preamble(struct net_device *dev,
8037 struct iw_request_info *info, 8037 struct iw_request_info *info,
8038 union iwreq_data *wrqu, char *extra) 8038 union iwreq_data *wrqu, char *extra)
8039 { 8039 {
8040 /* 8040 /*
8041 * This can be called at any time. No action lock required 8041 * This can be called at any time. No action lock required
8042 */ 8042 */
8043 8043
8044 struct ipw2100_priv *priv = libipw_priv(dev); 8044 struct ipw2100_priv *priv = libipw_priv(dev);
8045 8045
8046 if (priv->config & CFG_LONG_PREAMBLE) 8046 if (priv->config & CFG_LONG_PREAMBLE)
8047 snprintf(wrqu->name, IFNAMSIZ, "long (1)"); 8047 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
8048 else 8048 else
8049 snprintf(wrqu->name, IFNAMSIZ, "auto (0)"); 8049 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
8050 8050
8051 return 0; 8051 return 0;
8052 } 8052 }
8053 8053
8054 #ifdef CONFIG_IPW2100_MONITOR 8054 #ifdef CONFIG_IPW2100_MONITOR
8055 static int ipw2100_wx_set_crc_check(struct net_device *dev, 8055 static int ipw2100_wx_set_crc_check(struct net_device *dev,
8056 struct iw_request_info *info, 8056 struct iw_request_info *info,
8057 union iwreq_data *wrqu, char *extra) 8057 union iwreq_data *wrqu, char *extra)
8058 { 8058 {
8059 struct ipw2100_priv *priv = libipw_priv(dev); 8059 struct ipw2100_priv *priv = libipw_priv(dev);
8060 int err, mode = *(int *)extra; 8060 int err, mode = *(int *)extra;
8061 8061
8062 mutex_lock(&priv->action_mutex); 8062 mutex_lock(&priv->action_mutex);
8063 if (!(priv->status & STATUS_INITIALIZED)) { 8063 if (!(priv->status & STATUS_INITIALIZED)) {
8064 err = -EIO; 8064 err = -EIO;
8065 goto done; 8065 goto done;
8066 } 8066 }
8067 8067
8068 if (mode == 1) 8068 if (mode == 1)
8069 priv->config |= CFG_CRC_CHECK; 8069 priv->config |= CFG_CRC_CHECK;
8070 else if (mode == 0) 8070 else if (mode == 0)
8071 priv->config &= ~CFG_CRC_CHECK; 8071 priv->config &= ~CFG_CRC_CHECK;
8072 else { 8072 else {
8073 err = -EINVAL; 8073 err = -EINVAL;
8074 goto done; 8074 goto done;
8075 } 8075 }
8076 err = 0; 8076 err = 0;
8077 8077
8078 done: 8078 done:
8079 mutex_unlock(&priv->action_mutex); 8079 mutex_unlock(&priv->action_mutex);
8080 return err; 8080 return err;
8081 } 8081 }
8082 8082
8083 static int ipw2100_wx_get_crc_check(struct net_device *dev, 8083 static int ipw2100_wx_get_crc_check(struct net_device *dev,
8084 struct iw_request_info *info, 8084 struct iw_request_info *info,
8085 union iwreq_data *wrqu, char *extra) 8085 union iwreq_data *wrqu, char *extra)
8086 { 8086 {
8087 /* 8087 /*
8088 * This can be called at any time. No action lock required 8088 * This can be called at any time. No action lock required
8089 */ 8089 */
8090 8090
8091 struct ipw2100_priv *priv = libipw_priv(dev); 8091 struct ipw2100_priv *priv = libipw_priv(dev);
8092 8092
8093 if (priv->config & CFG_CRC_CHECK) 8093 if (priv->config & CFG_CRC_CHECK)
8094 snprintf(wrqu->name, IFNAMSIZ, "CRC checked (1)"); 8094 snprintf(wrqu->name, IFNAMSIZ, "CRC checked (1)");
8095 else 8095 else
8096 snprintf(wrqu->name, IFNAMSIZ, "CRC ignored (0)"); 8096 snprintf(wrqu->name, IFNAMSIZ, "CRC ignored (0)");
8097 8097
8098 return 0; 8098 return 0;
8099 } 8099 }
8100 #endif /* CONFIG_IPW2100_MONITOR */ 8100 #endif /* CONFIG_IPW2100_MONITOR */
8101 8101
8102 static iw_handler ipw2100_wx_handlers[] = { 8102 static iw_handler ipw2100_wx_handlers[] = {
8103 NULL, /* SIOCSIWCOMMIT */ 8103 NULL, /* SIOCSIWCOMMIT */
8104 ipw2100_wx_get_name, /* SIOCGIWNAME */ 8104 ipw2100_wx_get_name, /* SIOCGIWNAME */
8105 NULL, /* SIOCSIWNWID */ 8105 NULL, /* SIOCSIWNWID */
8106 NULL, /* SIOCGIWNWID */ 8106 NULL, /* SIOCGIWNWID */
8107 ipw2100_wx_set_freq, /* SIOCSIWFREQ */ 8107 ipw2100_wx_set_freq, /* SIOCSIWFREQ */
8108 ipw2100_wx_get_freq, /* SIOCGIWFREQ */ 8108 ipw2100_wx_get_freq, /* SIOCGIWFREQ */
8109 ipw2100_wx_set_mode, /* SIOCSIWMODE */ 8109 ipw2100_wx_set_mode, /* SIOCSIWMODE */
8110 ipw2100_wx_get_mode, /* SIOCGIWMODE */ 8110 ipw2100_wx_get_mode, /* SIOCGIWMODE */
8111 NULL, /* SIOCSIWSENS */ 8111 NULL, /* SIOCSIWSENS */
8112 NULL, /* SIOCGIWSENS */ 8112 NULL, /* SIOCGIWSENS */
8113 NULL, /* SIOCSIWRANGE */ 8113 NULL, /* SIOCSIWRANGE */
8114 ipw2100_wx_get_range, /* SIOCGIWRANGE */ 8114 ipw2100_wx_get_range, /* SIOCGIWRANGE */
8115 NULL, /* SIOCSIWPRIV */ 8115 NULL, /* SIOCSIWPRIV */
8116 NULL, /* SIOCGIWPRIV */ 8116 NULL, /* SIOCGIWPRIV */
8117 NULL, /* SIOCSIWSTATS */ 8117 NULL, /* SIOCSIWSTATS */
8118 NULL, /* SIOCGIWSTATS */ 8118 NULL, /* SIOCGIWSTATS */
8119 NULL, /* SIOCSIWSPY */ 8119 NULL, /* SIOCSIWSPY */
8120 NULL, /* SIOCGIWSPY */ 8120 NULL, /* SIOCGIWSPY */
8121 NULL, /* SIOCGIWTHRSPY */ 8121 NULL, /* SIOCGIWTHRSPY */
8122 NULL, /* SIOCWIWTHRSPY */ 8122 NULL, /* SIOCWIWTHRSPY */
8123 ipw2100_wx_set_wap, /* SIOCSIWAP */ 8123 ipw2100_wx_set_wap, /* SIOCSIWAP */
8124 ipw2100_wx_get_wap, /* SIOCGIWAP */ 8124 ipw2100_wx_get_wap, /* SIOCGIWAP */
8125 ipw2100_wx_set_mlme, /* SIOCSIWMLME */ 8125 ipw2100_wx_set_mlme, /* SIOCSIWMLME */
8126 NULL, /* SIOCGIWAPLIST -- deprecated */ 8126 NULL, /* SIOCGIWAPLIST -- deprecated */
8127 ipw2100_wx_set_scan, /* SIOCSIWSCAN */ 8127 ipw2100_wx_set_scan, /* SIOCSIWSCAN */
8128 ipw2100_wx_get_scan, /* SIOCGIWSCAN */ 8128 ipw2100_wx_get_scan, /* SIOCGIWSCAN */
8129 ipw2100_wx_set_essid, /* SIOCSIWESSID */ 8129 ipw2100_wx_set_essid, /* SIOCSIWESSID */
8130 ipw2100_wx_get_essid, /* SIOCGIWESSID */ 8130 ipw2100_wx_get_essid, /* SIOCGIWESSID */
8131 ipw2100_wx_set_nick, /* SIOCSIWNICKN */ 8131 ipw2100_wx_set_nick, /* SIOCSIWNICKN */
8132 ipw2100_wx_get_nick, /* SIOCGIWNICKN */ 8132 ipw2100_wx_get_nick, /* SIOCGIWNICKN */
8133 NULL, /* -- hole -- */ 8133 NULL, /* -- hole -- */
8134 NULL, /* -- hole -- */ 8134 NULL, /* -- hole -- */
8135 ipw2100_wx_set_rate, /* SIOCSIWRATE */ 8135 ipw2100_wx_set_rate, /* SIOCSIWRATE */
8136 ipw2100_wx_get_rate, /* SIOCGIWRATE */ 8136 ipw2100_wx_get_rate, /* SIOCGIWRATE */
8137 ipw2100_wx_set_rts, /* SIOCSIWRTS */ 8137 ipw2100_wx_set_rts, /* SIOCSIWRTS */
8138 ipw2100_wx_get_rts, /* SIOCGIWRTS */ 8138 ipw2100_wx_get_rts, /* SIOCGIWRTS */
8139 ipw2100_wx_set_frag, /* SIOCSIWFRAG */ 8139 ipw2100_wx_set_frag, /* SIOCSIWFRAG */
8140 ipw2100_wx_get_frag, /* SIOCGIWFRAG */ 8140 ipw2100_wx_get_frag, /* SIOCGIWFRAG */
8141 ipw2100_wx_set_txpow, /* SIOCSIWTXPOW */ 8141 ipw2100_wx_set_txpow, /* SIOCSIWTXPOW */
8142 ipw2100_wx_get_txpow, /* SIOCGIWTXPOW */ 8142 ipw2100_wx_get_txpow, /* SIOCGIWTXPOW */
8143 ipw2100_wx_set_retry, /* SIOCSIWRETRY */ 8143 ipw2100_wx_set_retry, /* SIOCSIWRETRY */
8144 ipw2100_wx_get_retry, /* SIOCGIWRETRY */ 8144 ipw2100_wx_get_retry, /* SIOCGIWRETRY */
8145 ipw2100_wx_set_encode, /* SIOCSIWENCODE */ 8145 ipw2100_wx_set_encode, /* SIOCSIWENCODE */
8146 ipw2100_wx_get_encode, /* SIOCGIWENCODE */ 8146 ipw2100_wx_get_encode, /* SIOCGIWENCODE */
8147 ipw2100_wx_set_power, /* SIOCSIWPOWER */ 8147 ipw2100_wx_set_power, /* SIOCSIWPOWER */
8148 ipw2100_wx_get_power, /* SIOCGIWPOWER */ 8148 ipw2100_wx_get_power, /* SIOCGIWPOWER */
8149 NULL, /* -- hole -- */ 8149 NULL, /* -- hole -- */
8150 NULL, /* -- hole -- */ 8150 NULL, /* -- hole -- */
8151 ipw2100_wx_set_genie, /* SIOCSIWGENIE */ 8151 ipw2100_wx_set_genie, /* SIOCSIWGENIE */
8152 ipw2100_wx_get_genie, /* SIOCGIWGENIE */ 8152 ipw2100_wx_get_genie, /* SIOCGIWGENIE */
8153 ipw2100_wx_set_auth, /* SIOCSIWAUTH */ 8153 ipw2100_wx_set_auth, /* SIOCSIWAUTH */
8154 ipw2100_wx_get_auth, /* SIOCGIWAUTH */ 8154 ipw2100_wx_get_auth, /* SIOCGIWAUTH */
8155 ipw2100_wx_set_encodeext, /* SIOCSIWENCODEEXT */ 8155 ipw2100_wx_set_encodeext, /* SIOCSIWENCODEEXT */
8156 ipw2100_wx_get_encodeext, /* SIOCGIWENCODEEXT */ 8156 ipw2100_wx_get_encodeext, /* SIOCGIWENCODEEXT */
8157 NULL, /* SIOCSIWPMKSA */ 8157 NULL, /* SIOCSIWPMKSA */
8158 }; 8158 };
8159 8159
8160 #define IPW2100_PRIV_SET_MONITOR SIOCIWFIRSTPRIV 8160 #define IPW2100_PRIV_SET_MONITOR SIOCIWFIRSTPRIV
8161 #define IPW2100_PRIV_RESET SIOCIWFIRSTPRIV+1 8161 #define IPW2100_PRIV_RESET SIOCIWFIRSTPRIV+1
8162 #define IPW2100_PRIV_SET_POWER SIOCIWFIRSTPRIV+2 8162 #define IPW2100_PRIV_SET_POWER SIOCIWFIRSTPRIV+2
8163 #define IPW2100_PRIV_GET_POWER SIOCIWFIRSTPRIV+3 8163 #define IPW2100_PRIV_GET_POWER SIOCIWFIRSTPRIV+3
8164 #define IPW2100_PRIV_SET_LONGPREAMBLE SIOCIWFIRSTPRIV+4 8164 #define IPW2100_PRIV_SET_LONGPREAMBLE SIOCIWFIRSTPRIV+4
8165 #define IPW2100_PRIV_GET_LONGPREAMBLE SIOCIWFIRSTPRIV+5 8165 #define IPW2100_PRIV_GET_LONGPREAMBLE SIOCIWFIRSTPRIV+5
8166 #define IPW2100_PRIV_SET_CRC_CHECK SIOCIWFIRSTPRIV+6 8166 #define IPW2100_PRIV_SET_CRC_CHECK SIOCIWFIRSTPRIV+6
8167 #define IPW2100_PRIV_GET_CRC_CHECK SIOCIWFIRSTPRIV+7 8167 #define IPW2100_PRIV_GET_CRC_CHECK SIOCIWFIRSTPRIV+7
8168 8168
8169 static const struct iw_priv_args ipw2100_private_args[] = { 8169 static const struct iw_priv_args ipw2100_private_args[] = {
8170 8170
8171 #ifdef CONFIG_IPW2100_MONITOR 8171 #ifdef CONFIG_IPW2100_MONITOR
8172 { 8172 {
8173 IPW2100_PRIV_SET_MONITOR, 8173 IPW2100_PRIV_SET_MONITOR,
8174 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"}, 8174 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
8175 { 8175 {
8176 IPW2100_PRIV_RESET, 8176 IPW2100_PRIV_RESET,
8177 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"}, 8177 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
8178 #endif /* CONFIG_IPW2100_MONITOR */ 8178 #endif /* CONFIG_IPW2100_MONITOR */
8179 8179
8180 { 8180 {
8181 IPW2100_PRIV_SET_POWER, 8181 IPW2100_PRIV_SET_POWER,
8182 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_power"}, 8182 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_power"},
8183 { 8183 {
8184 IPW2100_PRIV_GET_POWER, 8184 IPW2100_PRIV_GET_POWER,
8185 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_POWER_STRING, 8185 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_POWER_STRING,
8186 "get_power"}, 8186 "get_power"},
8187 { 8187 {
8188 IPW2100_PRIV_SET_LONGPREAMBLE, 8188 IPW2100_PRIV_SET_LONGPREAMBLE,
8189 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_preamble"}, 8189 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_preamble"},
8190 { 8190 {
8191 IPW2100_PRIV_GET_LONGPREAMBLE, 8191 IPW2100_PRIV_GET_LONGPREAMBLE,
8192 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "get_preamble"}, 8192 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "get_preamble"},
8193 #ifdef CONFIG_IPW2100_MONITOR 8193 #ifdef CONFIG_IPW2100_MONITOR
8194 { 8194 {
8195 IPW2100_PRIV_SET_CRC_CHECK, 8195 IPW2100_PRIV_SET_CRC_CHECK,
8196 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_crc_check"}, 8196 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_crc_check"},
8197 { 8197 {
8198 IPW2100_PRIV_GET_CRC_CHECK, 8198 IPW2100_PRIV_GET_CRC_CHECK,
8199 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "get_crc_check"}, 8199 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "get_crc_check"},
8200 #endif /* CONFIG_IPW2100_MONITOR */ 8200 #endif /* CONFIG_IPW2100_MONITOR */
8201 }; 8201 };
8202 8202
8203 static iw_handler ipw2100_private_handler[] = { 8203 static iw_handler ipw2100_private_handler[] = {
8204 #ifdef CONFIG_IPW2100_MONITOR 8204 #ifdef CONFIG_IPW2100_MONITOR
8205 ipw2100_wx_set_promisc, 8205 ipw2100_wx_set_promisc,
8206 ipw2100_wx_reset, 8206 ipw2100_wx_reset,
8207 #else /* CONFIG_IPW2100_MONITOR */ 8207 #else /* CONFIG_IPW2100_MONITOR */
8208 NULL, 8208 NULL,
8209 NULL, 8209 NULL,
8210 #endif /* CONFIG_IPW2100_MONITOR */ 8210 #endif /* CONFIG_IPW2100_MONITOR */
8211 ipw2100_wx_set_powermode, 8211 ipw2100_wx_set_powermode,
8212 ipw2100_wx_get_powermode, 8212 ipw2100_wx_get_powermode,
8213 ipw2100_wx_set_preamble, 8213 ipw2100_wx_set_preamble,
8214 ipw2100_wx_get_preamble, 8214 ipw2100_wx_get_preamble,
8215 #ifdef CONFIG_IPW2100_MONITOR 8215 #ifdef CONFIG_IPW2100_MONITOR
8216 ipw2100_wx_set_crc_check, 8216 ipw2100_wx_set_crc_check,
8217 ipw2100_wx_get_crc_check, 8217 ipw2100_wx_get_crc_check,
8218 #else /* CONFIG_IPW2100_MONITOR */ 8218 #else /* CONFIG_IPW2100_MONITOR */
8219 NULL, 8219 NULL,
8220 NULL, 8220 NULL,
8221 #endif /* CONFIG_IPW2100_MONITOR */ 8221 #endif /* CONFIG_IPW2100_MONITOR */
8222 }; 8222 };
8223 8223
8224 /* 8224 /*
8225 * Get wireless statistics. 8225 * Get wireless statistics.
8226 * Called by /proc/net/wireless 8226 * Called by /proc/net/wireless
8227 * Also called by SIOCGIWSTATS 8227 * Also called by SIOCGIWSTATS
8228 */ 8228 */
8229 static struct iw_statistics *ipw2100_wx_wireless_stats(struct net_device *dev) 8229 static struct iw_statistics *ipw2100_wx_wireless_stats(struct net_device *dev)
8230 { 8230 {
8231 enum { 8231 enum {
8232 POOR = 30, 8232 POOR = 30,
8233 FAIR = 60, 8233 FAIR = 60,
8234 GOOD = 80, 8234 GOOD = 80,
8235 VERY_GOOD = 90, 8235 VERY_GOOD = 90,
8236 EXCELLENT = 95, 8236 EXCELLENT = 95,
8237 PERFECT = 100 8237 PERFECT = 100
8238 }; 8238 };
8239 int rssi_qual; 8239 int rssi_qual;
8240 int tx_qual; 8240 int tx_qual;
8241 int beacon_qual; 8241 int beacon_qual;
8242 int quality; 8242 int quality;
8243 8243
8244 struct ipw2100_priv *priv = libipw_priv(dev); 8244 struct ipw2100_priv *priv = libipw_priv(dev);
8245 struct iw_statistics *wstats; 8245 struct iw_statistics *wstats;
8246 u32 rssi, tx_retries, missed_beacons, tx_failures; 8246 u32 rssi, tx_retries, missed_beacons, tx_failures;
8247 u32 ord_len = sizeof(u32); 8247 u32 ord_len = sizeof(u32);
8248 8248
8249 if (!priv) 8249 if (!priv)
8250 return (struct iw_statistics *)NULL; 8250 return (struct iw_statistics *)NULL;
8251 8251
8252 wstats = &priv->wstats; 8252 wstats = &priv->wstats;
8253 8253
8254 /* if hw is disabled, then ipw2100_get_ordinal() can't be called. 8254 /* if hw is disabled, then ipw2100_get_ordinal() can't be called.
8255 * ipw2100_wx_wireless_stats seems to be called before fw is 8255 * ipw2100_wx_wireless_stats seems to be called before fw is
8256 * initialized. STATUS_ASSOCIATED will only be set if the hw is up 8256 * initialized. STATUS_ASSOCIATED will only be set if the hw is up
8257 * and associated; if not associcated, the values are all meaningless 8257 * and associated; if not associcated, the values are all meaningless
8258 * anyway, so set them all to NULL and INVALID */ 8258 * anyway, so set them all to NULL and INVALID */
8259 if (!(priv->status & STATUS_ASSOCIATED)) { 8259 if (!(priv->status & STATUS_ASSOCIATED)) {
8260 wstats->miss.beacon = 0; 8260 wstats->miss.beacon = 0;
8261 wstats->discard.retries = 0; 8261 wstats->discard.retries = 0;
8262 wstats->qual.qual = 0; 8262 wstats->qual.qual = 0;
8263 wstats->qual.level = 0; 8263 wstats->qual.level = 0;
8264 wstats->qual.noise = 0; 8264 wstats->qual.noise = 0;
8265 wstats->qual.updated = 7; 8265 wstats->qual.updated = 7;
8266 wstats->qual.updated |= IW_QUAL_NOISE_INVALID | 8266 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
8267 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID; 8267 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
8268 return wstats; 8268 return wstats;
8269 } 8269 }
8270 8270
8271 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_PERCENT_MISSED_BCNS, 8271 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_PERCENT_MISSED_BCNS,
8272 &missed_beacons, &ord_len)) 8272 &missed_beacons, &ord_len))
8273 goto fail_get_ordinal; 8273 goto fail_get_ordinal;
8274 8274
8275 /* If we don't have a connection the quality and level is 0 */ 8275 /* If we don't have a connection the quality and level is 0 */
8276 if (!(priv->status & STATUS_ASSOCIATED)) { 8276 if (!(priv->status & STATUS_ASSOCIATED)) {
8277 wstats->qual.qual = 0; 8277 wstats->qual.qual = 0;
8278 wstats->qual.level = 0; 8278 wstats->qual.level = 0;
8279 } else { 8279 } else {
8280 if (ipw2100_get_ordinal(priv, IPW_ORD_RSSI_AVG_CURR, 8280 if (ipw2100_get_ordinal(priv, IPW_ORD_RSSI_AVG_CURR,
8281 &rssi, &ord_len)) 8281 &rssi, &ord_len))
8282 goto fail_get_ordinal; 8282 goto fail_get_ordinal;
8283 wstats->qual.level = rssi + IPW2100_RSSI_TO_DBM; 8283 wstats->qual.level = rssi + IPW2100_RSSI_TO_DBM;
8284 if (rssi < 10) 8284 if (rssi < 10)
8285 rssi_qual = rssi * POOR / 10; 8285 rssi_qual = rssi * POOR / 10;
8286 else if (rssi < 15) 8286 else if (rssi < 15)
8287 rssi_qual = (rssi - 10) * (FAIR - POOR) / 5 + POOR; 8287 rssi_qual = (rssi - 10) * (FAIR - POOR) / 5 + POOR;
8288 else if (rssi < 20) 8288 else if (rssi < 20)
8289 rssi_qual = (rssi - 15) * (GOOD - FAIR) / 5 + FAIR; 8289 rssi_qual = (rssi - 15) * (GOOD - FAIR) / 5 + FAIR;
8290 else if (rssi < 30) 8290 else if (rssi < 30)
8291 rssi_qual = (rssi - 20) * (VERY_GOOD - GOOD) / 8291 rssi_qual = (rssi - 20) * (VERY_GOOD - GOOD) /
8292 10 + GOOD; 8292 10 + GOOD;
8293 else 8293 else
8294 rssi_qual = (rssi - 30) * (PERFECT - VERY_GOOD) / 8294 rssi_qual = (rssi - 30) * (PERFECT - VERY_GOOD) /
8295 10 + VERY_GOOD; 8295 10 + VERY_GOOD;
8296 8296
8297 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_PERCENT_RETRIES, 8297 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_PERCENT_RETRIES,
8298 &tx_retries, &ord_len)) 8298 &tx_retries, &ord_len))
8299 goto fail_get_ordinal; 8299 goto fail_get_ordinal;
8300 8300
8301 if (tx_retries > 75) 8301 if (tx_retries > 75)
8302 tx_qual = (90 - tx_retries) * POOR / 15; 8302 tx_qual = (90 - tx_retries) * POOR / 15;
8303 else if (tx_retries > 70) 8303 else if (tx_retries > 70)
8304 tx_qual = (75 - tx_retries) * (FAIR - POOR) / 5 + POOR; 8304 tx_qual = (75 - tx_retries) * (FAIR - POOR) / 5 + POOR;
8305 else if (tx_retries > 65) 8305 else if (tx_retries > 65)
8306 tx_qual = (70 - tx_retries) * (GOOD - FAIR) / 5 + FAIR; 8306 tx_qual = (70 - tx_retries) * (GOOD - FAIR) / 5 + FAIR;
8307 else if (tx_retries > 50) 8307 else if (tx_retries > 50)
8308 tx_qual = (65 - tx_retries) * (VERY_GOOD - GOOD) / 8308 tx_qual = (65 - tx_retries) * (VERY_GOOD - GOOD) /
8309 15 + GOOD; 8309 15 + GOOD;
8310 else 8310 else
8311 tx_qual = (50 - tx_retries) * 8311 tx_qual = (50 - tx_retries) *
8312 (PERFECT - VERY_GOOD) / 50 + VERY_GOOD; 8312 (PERFECT - VERY_GOOD) / 50 + VERY_GOOD;
8313 8313
8314 if (missed_beacons > 50) 8314 if (missed_beacons > 50)
8315 beacon_qual = (60 - missed_beacons) * POOR / 10; 8315 beacon_qual = (60 - missed_beacons) * POOR / 10;
8316 else if (missed_beacons > 40) 8316 else if (missed_beacons > 40)
8317 beacon_qual = (50 - missed_beacons) * (FAIR - POOR) / 8317 beacon_qual = (50 - missed_beacons) * (FAIR - POOR) /
8318 10 + POOR; 8318 10 + POOR;
8319 else if (missed_beacons > 32) 8319 else if (missed_beacons > 32)
8320 beacon_qual = (40 - missed_beacons) * (GOOD - FAIR) / 8320 beacon_qual = (40 - missed_beacons) * (GOOD - FAIR) /
8321 18 + FAIR; 8321 18 + FAIR;
8322 else if (missed_beacons > 20) 8322 else if (missed_beacons > 20)
8323 beacon_qual = (32 - missed_beacons) * 8323 beacon_qual = (32 - missed_beacons) *
8324 (VERY_GOOD - GOOD) / 20 + GOOD; 8324 (VERY_GOOD - GOOD) / 20 + GOOD;
8325 else 8325 else
8326 beacon_qual = (20 - missed_beacons) * 8326 beacon_qual = (20 - missed_beacons) *
8327 (PERFECT - VERY_GOOD) / 20 + VERY_GOOD; 8327 (PERFECT - VERY_GOOD) / 20 + VERY_GOOD;
8328 8328
8329 quality = min(tx_qual, rssi_qual); 8329 quality = min(tx_qual, rssi_qual);
8330 quality = min(beacon_qual, quality); 8330 quality = min(beacon_qual, quality);
8331 8331
8332 #ifdef CONFIG_IPW2100_DEBUG 8332 #ifdef CONFIG_IPW2100_DEBUG
8333 if (beacon_qual == quality) 8333 if (beacon_qual == quality)
8334 IPW_DEBUG_WX("Quality clamped by Missed Beacons\n"); 8334 IPW_DEBUG_WX("Quality clamped by Missed Beacons\n");
8335 else if (tx_qual == quality) 8335 else if (tx_qual == quality)
8336 IPW_DEBUG_WX("Quality clamped by Tx Retries\n"); 8336 IPW_DEBUG_WX("Quality clamped by Tx Retries\n");
8337 else if (quality != 100) 8337 else if (quality != 100)
8338 IPW_DEBUG_WX("Quality clamped by Signal Strength\n"); 8338 IPW_DEBUG_WX("Quality clamped by Signal Strength\n");
8339 else 8339 else
8340 IPW_DEBUG_WX("Quality not clamped.\n"); 8340 IPW_DEBUG_WX("Quality not clamped.\n");
8341 #endif 8341 #endif
8342 8342
8343 wstats->qual.qual = quality; 8343 wstats->qual.qual = quality;
8344 wstats->qual.level = rssi + IPW2100_RSSI_TO_DBM; 8344 wstats->qual.level = rssi + IPW2100_RSSI_TO_DBM;
8345 } 8345 }
8346 8346
8347 wstats->qual.noise = 0; 8347 wstats->qual.noise = 0;
8348 wstats->qual.updated = 7; 8348 wstats->qual.updated = 7;
8349 wstats->qual.updated |= IW_QUAL_NOISE_INVALID; 8349 wstats->qual.updated |= IW_QUAL_NOISE_INVALID;
8350 8350
8351 /* FIXME: this is percent and not a # */ 8351 /* FIXME: this is percent and not a # */
8352 wstats->miss.beacon = missed_beacons; 8352 wstats->miss.beacon = missed_beacons;
8353 8353
8354 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURES, 8354 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURES,
8355 &tx_failures, &ord_len)) 8355 &tx_failures, &ord_len))
8356 goto fail_get_ordinal; 8356 goto fail_get_ordinal;
8357 wstats->discard.retries = tx_failures; 8357 wstats->discard.retries = tx_failures;
8358 8358
8359 return wstats; 8359 return wstats;
8360 8360
8361 fail_get_ordinal: 8361 fail_get_ordinal:
8362 IPW_DEBUG_WX("failed querying ordinals.\n"); 8362 IPW_DEBUG_WX("failed querying ordinals.\n");
8363 8363
8364 return (struct iw_statistics *)NULL; 8364 return (struct iw_statistics *)NULL;
8365 } 8365 }
8366 8366
8367 static struct iw_handler_def ipw2100_wx_handler_def = { 8367 static struct iw_handler_def ipw2100_wx_handler_def = {
8368 .standard = ipw2100_wx_handlers, 8368 .standard = ipw2100_wx_handlers,
8369 .num_standard = ARRAY_SIZE(ipw2100_wx_handlers), 8369 .num_standard = ARRAY_SIZE(ipw2100_wx_handlers),
8370 .num_private = ARRAY_SIZE(ipw2100_private_handler), 8370 .num_private = ARRAY_SIZE(ipw2100_private_handler),
8371 .num_private_args = ARRAY_SIZE(ipw2100_private_args), 8371 .num_private_args = ARRAY_SIZE(ipw2100_private_args),
8372 .private = (iw_handler *) ipw2100_private_handler, 8372 .private = (iw_handler *) ipw2100_private_handler,
8373 .private_args = (struct iw_priv_args *)ipw2100_private_args, 8373 .private_args = (struct iw_priv_args *)ipw2100_private_args,
8374 .get_wireless_stats = ipw2100_wx_wireless_stats, 8374 .get_wireless_stats = ipw2100_wx_wireless_stats,
8375 }; 8375 };
8376 8376
8377 static void ipw2100_wx_event_work(struct work_struct *work) 8377 static void ipw2100_wx_event_work(struct work_struct *work)
8378 { 8378 {
8379 struct ipw2100_priv *priv = 8379 struct ipw2100_priv *priv =
8380 container_of(work, struct ipw2100_priv, wx_event_work.work); 8380 container_of(work, struct ipw2100_priv, wx_event_work.work);
8381 union iwreq_data wrqu; 8381 union iwreq_data wrqu;
8382 unsigned int len = ETH_ALEN; 8382 unsigned int len = ETH_ALEN;
8383 8383
8384 if (priv->status & STATUS_STOPPING) 8384 if (priv->status & STATUS_STOPPING)
8385 return; 8385 return;
8386 8386
8387 mutex_lock(&priv->action_mutex); 8387 mutex_lock(&priv->action_mutex);
8388 8388
8389 IPW_DEBUG_WX("enter\n"); 8389 IPW_DEBUG_WX("enter\n");
8390 8390
8391 mutex_unlock(&priv->action_mutex); 8391 mutex_unlock(&priv->action_mutex);
8392 8392
8393 wrqu.ap_addr.sa_family = ARPHRD_ETHER; 8393 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
8394 8394
8395 /* Fetch BSSID from the hardware */ 8395 /* Fetch BSSID from the hardware */
8396 if (!(priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED)) || 8396 if (!(priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED)) ||
8397 priv->status & STATUS_RF_KILL_MASK || 8397 priv->status & STATUS_RF_KILL_MASK ||
8398 ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID, 8398 ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID,
8399 &priv->bssid, &len)) { 8399 &priv->bssid, &len)) {
8400 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN); 8400 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
8401 } else { 8401 } else {
8402 /* We now have the BSSID, so can finish setting to the full 8402 /* We now have the BSSID, so can finish setting to the full
8403 * associated state */ 8403 * associated state */
8404 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN); 8404 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
8405 memcpy(priv->ieee->bssid, priv->bssid, ETH_ALEN); 8405 memcpy(priv->ieee->bssid, priv->bssid, ETH_ALEN);
8406 priv->status &= ~STATUS_ASSOCIATING; 8406 priv->status &= ~STATUS_ASSOCIATING;
8407 priv->status |= STATUS_ASSOCIATED; 8407 priv->status |= STATUS_ASSOCIATED;
8408 netif_carrier_on(priv->net_dev); 8408 netif_carrier_on(priv->net_dev);
8409 netif_wake_queue(priv->net_dev); 8409 netif_wake_queue(priv->net_dev);
8410 } 8410 }
8411 8411
8412 if (!(priv->status & STATUS_ASSOCIATED)) { 8412 if (!(priv->status & STATUS_ASSOCIATED)) {
8413 IPW_DEBUG_WX("Configuring ESSID\n"); 8413 IPW_DEBUG_WX("Configuring ESSID\n");
8414 mutex_lock(&priv->action_mutex); 8414 mutex_lock(&priv->action_mutex);
8415 /* This is a disassociation event, so kick the firmware to 8415 /* This is a disassociation event, so kick the firmware to
8416 * look for another AP */ 8416 * look for another AP */
8417 if (priv->config & CFG_STATIC_ESSID) 8417 if (priv->config & CFG_STATIC_ESSID)
8418 ipw2100_set_essid(priv, priv->essid, priv->essid_len, 8418 ipw2100_set_essid(priv, priv->essid, priv->essid_len,
8419 0); 8419 0);
8420 else 8420 else
8421 ipw2100_set_essid(priv, NULL, 0, 0); 8421 ipw2100_set_essid(priv, NULL, 0, 0);
8422 mutex_unlock(&priv->action_mutex); 8422 mutex_unlock(&priv->action_mutex);
8423 } 8423 }
8424 8424
8425 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL); 8425 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
8426 } 8426 }
8427 8427
8428 #define IPW2100_FW_MAJOR_VERSION 1 8428 #define IPW2100_FW_MAJOR_VERSION 1
8429 #define IPW2100_FW_MINOR_VERSION 3 8429 #define IPW2100_FW_MINOR_VERSION 3
8430 8430
8431 #define IPW2100_FW_MINOR(x) ((x & 0xff) >> 8) 8431 #define IPW2100_FW_MINOR(x) ((x & 0xff) >> 8)
8432 #define IPW2100_FW_MAJOR(x) (x & 0xff) 8432 #define IPW2100_FW_MAJOR(x) (x & 0xff)
8433 8433
8434 #define IPW2100_FW_VERSION ((IPW2100_FW_MINOR_VERSION << 8) | \ 8434 #define IPW2100_FW_VERSION ((IPW2100_FW_MINOR_VERSION << 8) | \
8435 IPW2100_FW_MAJOR_VERSION) 8435 IPW2100_FW_MAJOR_VERSION)
8436 8436
8437 #define IPW2100_FW_PREFIX "ipw2100-" __stringify(IPW2100_FW_MAJOR_VERSION) \ 8437 #define IPW2100_FW_PREFIX "ipw2100-" __stringify(IPW2100_FW_MAJOR_VERSION) \
8438 "." __stringify(IPW2100_FW_MINOR_VERSION) 8438 "." __stringify(IPW2100_FW_MINOR_VERSION)
8439 8439
8440 #define IPW2100_FW_NAME(x) IPW2100_FW_PREFIX "" x ".fw" 8440 #define IPW2100_FW_NAME(x) IPW2100_FW_PREFIX "" x ".fw"
8441 8441
8442 /* 8442 /*
8443 8443
8444 BINARY FIRMWARE HEADER FORMAT 8444 BINARY FIRMWARE HEADER FORMAT
8445 8445
8446 offset length desc 8446 offset length desc
8447 0 2 version 8447 0 2 version
8448 2 2 mode == 0:BSS,1:IBSS,2:MONITOR 8448 2 2 mode == 0:BSS,1:IBSS,2:MONITOR
8449 4 4 fw_len 8449 4 4 fw_len
8450 8 4 uc_len 8450 8 4 uc_len
8451 C fw_len firmware data 8451 C fw_len firmware data
8452 12 + fw_len uc_len microcode data 8452 12 + fw_len uc_len microcode data
8453 8453
8454 */ 8454 */
8455 8455
8456 struct ipw2100_fw_header { 8456 struct ipw2100_fw_header {
8457 short version; 8457 short version;
8458 short mode; 8458 short mode;
8459 unsigned int fw_size; 8459 unsigned int fw_size;
8460 unsigned int uc_size; 8460 unsigned int uc_size;
8461 } __packed; 8461 } __packed;
8462 8462
8463 static int ipw2100_mod_firmware_load(struct ipw2100_fw *fw) 8463 static int ipw2100_mod_firmware_load(struct ipw2100_fw *fw)
8464 { 8464 {
8465 struct ipw2100_fw_header *h = 8465 struct ipw2100_fw_header *h =
8466 (struct ipw2100_fw_header *)fw->fw_entry->data; 8466 (struct ipw2100_fw_header *)fw->fw_entry->data;
8467 8467
8468 if (IPW2100_FW_MAJOR(h->version) != IPW2100_FW_MAJOR_VERSION) { 8468 if (IPW2100_FW_MAJOR(h->version) != IPW2100_FW_MAJOR_VERSION) {
8469 printk(KERN_WARNING DRV_NAME ": Firmware image not compatible " 8469 printk(KERN_WARNING DRV_NAME ": Firmware image not compatible "
8470 "(detected version id of %u). " 8470 "(detected version id of %u). "
8471 "See Documentation/networking/README.ipw2100\n", 8471 "See Documentation/networking/README.ipw2100\n",
8472 h->version); 8472 h->version);
8473 return 1; 8473 return 1;
8474 } 8474 }
8475 8475
8476 fw->version = h->version; 8476 fw->version = h->version;
8477 fw->fw.data = fw->fw_entry->data + sizeof(struct ipw2100_fw_header); 8477 fw->fw.data = fw->fw_entry->data + sizeof(struct ipw2100_fw_header);
8478 fw->fw.size = h->fw_size; 8478 fw->fw.size = h->fw_size;
8479 fw->uc.data = fw->fw.data + h->fw_size; 8479 fw->uc.data = fw->fw.data + h->fw_size;
8480 fw->uc.size = h->uc_size; 8480 fw->uc.size = h->uc_size;
8481 8481
8482 return 0; 8482 return 0;
8483 } 8483 }
8484 8484
8485 static int ipw2100_get_firmware(struct ipw2100_priv *priv, 8485 static int ipw2100_get_firmware(struct ipw2100_priv *priv,
8486 struct ipw2100_fw *fw) 8486 struct ipw2100_fw *fw)
8487 { 8487 {
8488 char *fw_name; 8488 char *fw_name;
8489 int rc; 8489 int rc;
8490 8490
8491 IPW_DEBUG_INFO("%s: Using hotplug firmware load.\n", 8491 IPW_DEBUG_INFO("%s: Using hotplug firmware load.\n",
8492 priv->net_dev->name); 8492 priv->net_dev->name);
8493 8493
8494 switch (priv->ieee->iw_mode) { 8494 switch (priv->ieee->iw_mode) {
8495 case IW_MODE_ADHOC: 8495 case IW_MODE_ADHOC:
8496 fw_name = IPW2100_FW_NAME("-i"); 8496 fw_name = IPW2100_FW_NAME("-i");
8497 break; 8497 break;
8498 #ifdef CONFIG_IPW2100_MONITOR 8498 #ifdef CONFIG_IPW2100_MONITOR
8499 case IW_MODE_MONITOR: 8499 case IW_MODE_MONITOR:
8500 fw_name = IPW2100_FW_NAME("-p"); 8500 fw_name = IPW2100_FW_NAME("-p");
8501 break; 8501 break;
8502 #endif 8502 #endif
8503 case IW_MODE_INFRA: 8503 case IW_MODE_INFRA:
8504 default: 8504 default:
8505 fw_name = IPW2100_FW_NAME(""); 8505 fw_name = IPW2100_FW_NAME("");
8506 break; 8506 break;
8507 } 8507 }
8508 8508
8509 rc = request_firmware(&fw->fw_entry, fw_name, &priv->pci_dev->dev); 8509 rc = request_firmware(&fw->fw_entry, fw_name, &priv->pci_dev->dev);
8510 8510
8511 if (rc < 0) { 8511 if (rc < 0) {
8512 printk(KERN_ERR DRV_NAME ": " 8512 printk(KERN_ERR DRV_NAME ": "
8513 "%s: Firmware '%s' not available or load failed.\n", 8513 "%s: Firmware '%s' not available or load failed.\n",
8514 priv->net_dev->name, fw_name); 8514 priv->net_dev->name, fw_name);
8515 return rc; 8515 return rc;
8516 } 8516 }
8517 IPW_DEBUG_INFO("firmware data %p size %zd\n", fw->fw_entry->data, 8517 IPW_DEBUG_INFO("firmware data %p size %zd\n", fw->fw_entry->data,
8518 fw->fw_entry->size); 8518 fw->fw_entry->size);
8519 8519
8520 ipw2100_mod_firmware_load(fw); 8520 ipw2100_mod_firmware_load(fw);
8521 8521
8522 return 0; 8522 return 0;
8523 } 8523 }
8524 8524
8525 MODULE_FIRMWARE(IPW2100_FW_NAME("-i")); 8525 MODULE_FIRMWARE(IPW2100_FW_NAME("-i"));
8526 #ifdef CONFIG_IPW2100_MONITOR 8526 #ifdef CONFIG_IPW2100_MONITOR
8527 MODULE_FIRMWARE(IPW2100_FW_NAME("-p")); 8527 MODULE_FIRMWARE(IPW2100_FW_NAME("-p"));
8528 #endif 8528 #endif
8529 MODULE_FIRMWARE(IPW2100_FW_NAME("")); 8529 MODULE_FIRMWARE(IPW2100_FW_NAME(""));
8530 8530
8531 static void ipw2100_release_firmware(struct ipw2100_priv *priv, 8531 static void ipw2100_release_firmware(struct ipw2100_priv *priv,
8532 struct ipw2100_fw *fw) 8532 struct ipw2100_fw *fw)
8533 { 8533 {
8534 fw->version = 0; 8534 fw->version = 0;
8535 if (fw->fw_entry) 8535 if (fw->fw_entry)
8536 release_firmware(fw->fw_entry); 8536 release_firmware(fw->fw_entry);
8537 fw->fw_entry = NULL; 8537 fw->fw_entry = NULL;
8538 } 8538 }
8539 8539
8540 static int ipw2100_get_fwversion(struct ipw2100_priv *priv, char *buf, 8540 static int ipw2100_get_fwversion(struct ipw2100_priv *priv, char *buf,
8541 size_t max) 8541 size_t max)
8542 { 8542 {
8543 char ver[MAX_FW_VERSION_LEN]; 8543 char ver[MAX_FW_VERSION_LEN];
8544 u32 len = MAX_FW_VERSION_LEN; 8544 u32 len = MAX_FW_VERSION_LEN;
8545 u32 tmp; 8545 u32 tmp;
8546 int i; 8546 int i;
8547 /* firmware version is an ascii string (max len of 14) */ 8547 /* firmware version is an ascii string (max len of 14) */
8548 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_FW_VER_NUM, ver, &len)) 8548 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_FW_VER_NUM, ver, &len))
8549 return -EIO; 8549 return -EIO;
8550 tmp = max; 8550 tmp = max;
8551 if (len >= max) 8551 if (len >= max)
8552 len = max - 1; 8552 len = max - 1;
8553 for (i = 0; i < len; i++) 8553 for (i = 0; i < len; i++)
8554 buf[i] = ver[i]; 8554 buf[i] = ver[i];
8555 buf[i] = '\0'; 8555 buf[i] = '\0';
8556 return tmp; 8556 return tmp;
8557 } 8557 }
8558 8558
8559 static int ipw2100_get_ucodeversion(struct ipw2100_priv *priv, char *buf, 8559 static int ipw2100_get_ucodeversion(struct ipw2100_priv *priv, char *buf,
8560 size_t max) 8560 size_t max)
8561 { 8561 {
8562 u32 ver; 8562 u32 ver;
8563 u32 len = sizeof(ver); 8563 u32 len = sizeof(ver);
8564 /* microcode version is a 32 bit integer */ 8564 /* microcode version is a 32 bit integer */
8565 if (ipw2100_get_ordinal(priv, IPW_ORD_UCODE_VERSION, &ver, &len)) 8565 if (ipw2100_get_ordinal(priv, IPW_ORD_UCODE_VERSION, &ver, &len))
8566 return -EIO; 8566 return -EIO;
8567 return snprintf(buf, max, "%08X", ver); 8567 return snprintf(buf, max, "%08X", ver);
8568 } 8568 }
8569 8569
8570 /* 8570 /*
8571 * On exit, the firmware will have been freed from the fw list 8571 * On exit, the firmware will have been freed from the fw list
8572 */ 8572 */
8573 static int ipw2100_fw_download(struct ipw2100_priv *priv, struct ipw2100_fw *fw) 8573 static int ipw2100_fw_download(struct ipw2100_priv *priv, struct ipw2100_fw *fw)
8574 { 8574 {
8575 /* firmware is constructed of N contiguous entries, each entry is 8575 /* firmware is constructed of N contiguous entries, each entry is
8576 * structured as: 8576 * structured as:
8577 * 8577 *
8578 * offset sie desc 8578 * offset sie desc
8579 * 0 4 address to write to 8579 * 0 4 address to write to
8580 * 4 2 length of data run 8580 * 4 2 length of data run
8581 * 6 length data 8581 * 6 length data
8582 */ 8582 */
8583 unsigned int addr; 8583 unsigned int addr;
8584 unsigned short len; 8584 unsigned short len;
8585 8585
8586 const unsigned char *firmware_data = fw->fw.data; 8586 const unsigned char *firmware_data = fw->fw.data;
8587 unsigned int firmware_data_left = fw->fw.size; 8587 unsigned int firmware_data_left = fw->fw.size;
8588 8588
8589 while (firmware_data_left > 0) { 8589 while (firmware_data_left > 0) {
8590 addr = *(u32 *) (firmware_data); 8590 addr = *(u32 *) (firmware_data);
8591 firmware_data += 4; 8591 firmware_data += 4;
8592 firmware_data_left -= 4; 8592 firmware_data_left -= 4;
8593 8593
8594 len = *(u16 *) (firmware_data); 8594 len = *(u16 *) (firmware_data);
8595 firmware_data += 2; 8595 firmware_data += 2;
8596 firmware_data_left -= 2; 8596 firmware_data_left -= 2;
8597 8597
8598 if (len > 32) { 8598 if (len > 32) {
8599 printk(KERN_ERR DRV_NAME ": " 8599 printk(KERN_ERR DRV_NAME ": "
8600 "Invalid firmware run-length of %d bytes\n", 8600 "Invalid firmware run-length of %d bytes\n",
8601 len); 8601 len);
8602 return -EINVAL; 8602 return -EINVAL;
8603 } 8603 }
8604 8604
8605 write_nic_memory(priv->net_dev, addr, len, firmware_data); 8605 write_nic_memory(priv->net_dev, addr, len, firmware_data);
8606 firmware_data += len; 8606 firmware_data += len;
8607 firmware_data_left -= len; 8607 firmware_data_left -= len;
8608 } 8608 }
8609 8609
8610 return 0; 8610 return 0;
8611 } 8611 }
8612 8612
8613 struct symbol_alive_response { 8613 struct symbol_alive_response {
8614 u8 cmd_id; 8614 u8 cmd_id;
8615 u8 seq_num; 8615 u8 seq_num;
8616 u8 ucode_rev; 8616 u8 ucode_rev;
8617 u8 eeprom_valid; 8617 u8 eeprom_valid;
8618 u16 valid_flags; 8618 u16 valid_flags;
8619 u8 IEEE_addr[6]; 8619 u8 IEEE_addr[6];
8620 u16 flags; 8620 u16 flags;
8621 u16 pcb_rev; 8621 u16 pcb_rev;
8622 u16 clock_settle_time; // 1us LSB 8622 u16 clock_settle_time; // 1us LSB
8623 u16 powerup_settle_time; // 1us LSB 8623 u16 powerup_settle_time; // 1us LSB
8624 u16 hop_settle_time; // 1us LSB 8624 u16 hop_settle_time; // 1us LSB
8625 u8 date[3]; // month, day, year 8625 u8 date[3]; // month, day, year
8626 u8 time[2]; // hours, minutes 8626 u8 time[2]; // hours, minutes
8627 u8 ucode_valid; 8627 u8 ucode_valid;
8628 }; 8628 };
8629 8629
8630 static int ipw2100_ucode_download(struct ipw2100_priv *priv, 8630 static int ipw2100_ucode_download(struct ipw2100_priv *priv,
8631 struct ipw2100_fw *fw) 8631 struct ipw2100_fw *fw)
8632 { 8632 {
8633 struct net_device *dev = priv->net_dev; 8633 struct net_device *dev = priv->net_dev;
8634 const unsigned char *microcode_data = fw->uc.data; 8634 const unsigned char *microcode_data = fw->uc.data;
8635 unsigned int microcode_data_left = fw->uc.size; 8635 unsigned int microcode_data_left = fw->uc.size;
8636 void __iomem *reg = (void __iomem *)dev->base_addr; 8636 void __iomem *reg = (void __iomem *)dev->base_addr;
8637 8637
8638 struct symbol_alive_response response; 8638 struct symbol_alive_response response;
8639 int i, j; 8639 int i, j;
8640 u8 data; 8640 u8 data;
8641 8641
8642 /* Symbol control */ 8642 /* Symbol control */
8643 write_nic_word(dev, IPW2100_CONTROL_REG, 0x703); 8643 write_nic_word(dev, IPW2100_CONTROL_REG, 0x703);
8644 readl(reg); 8644 readl(reg);
8645 write_nic_word(dev, IPW2100_CONTROL_REG, 0x707); 8645 write_nic_word(dev, IPW2100_CONTROL_REG, 0x707);
8646 readl(reg); 8646 readl(reg);
8647 8647
8648 /* HW config */ 8648 /* HW config */
8649 write_nic_byte(dev, 0x210014, 0x72); /* fifo width =16 */ 8649 write_nic_byte(dev, 0x210014, 0x72); /* fifo width =16 */
8650 readl(reg); 8650 readl(reg);
8651 write_nic_byte(dev, 0x210014, 0x72); /* fifo width =16 */ 8651 write_nic_byte(dev, 0x210014, 0x72); /* fifo width =16 */
8652 readl(reg); 8652 readl(reg);
8653 8653
8654 /* EN_CS_ACCESS bit to reset control store pointer */ 8654 /* EN_CS_ACCESS bit to reset control store pointer */
8655 write_nic_byte(dev, 0x210000, 0x40); 8655 write_nic_byte(dev, 0x210000, 0x40);
8656 readl(reg); 8656 readl(reg);
8657 write_nic_byte(dev, 0x210000, 0x0); 8657 write_nic_byte(dev, 0x210000, 0x0);
8658 readl(reg); 8658 readl(reg);
8659 write_nic_byte(dev, 0x210000, 0x40); 8659 write_nic_byte(dev, 0x210000, 0x40);
8660 readl(reg); 8660 readl(reg);
8661 8661
8662 /* copy microcode from buffer into Symbol */ 8662 /* copy microcode from buffer into Symbol */
8663 8663
8664 while (microcode_data_left > 0) { 8664 while (microcode_data_left > 0) {
8665 write_nic_byte(dev, 0x210010, *microcode_data++); 8665 write_nic_byte(dev, 0x210010, *microcode_data++);
8666 write_nic_byte(dev, 0x210010, *microcode_data++); 8666 write_nic_byte(dev, 0x210010, *microcode_data++);
8667 microcode_data_left -= 2; 8667 microcode_data_left -= 2;
8668 } 8668 }
8669 8669
8670 /* EN_CS_ACCESS bit to reset the control store pointer */ 8670 /* EN_CS_ACCESS bit to reset the control store pointer */
8671 write_nic_byte(dev, 0x210000, 0x0); 8671 write_nic_byte(dev, 0x210000, 0x0);
8672 readl(reg); 8672 readl(reg);
8673 8673
8674 /* Enable System (Reg 0) 8674 /* Enable System (Reg 0)
8675 * first enable causes garbage in RX FIFO */ 8675 * first enable causes garbage in RX FIFO */
8676 write_nic_byte(dev, 0x210000, 0x0); 8676 write_nic_byte(dev, 0x210000, 0x0);
8677 readl(reg); 8677 readl(reg);
8678 write_nic_byte(dev, 0x210000, 0x80); 8678 write_nic_byte(dev, 0x210000, 0x80);
8679 readl(reg); 8679 readl(reg);
8680 8680
8681 /* Reset External Baseband Reg */ 8681 /* Reset External Baseband Reg */
8682 write_nic_word(dev, IPW2100_CONTROL_REG, 0x703); 8682 write_nic_word(dev, IPW2100_CONTROL_REG, 0x703);
8683 readl(reg); 8683 readl(reg);
8684 write_nic_word(dev, IPW2100_CONTROL_REG, 0x707); 8684 write_nic_word(dev, IPW2100_CONTROL_REG, 0x707);
8685 readl(reg); 8685 readl(reg);
8686 8686
8687 /* HW Config (Reg 5) */ 8687 /* HW Config (Reg 5) */
8688 write_nic_byte(dev, 0x210014, 0x72); // fifo width =16 8688 write_nic_byte(dev, 0x210014, 0x72); // fifo width =16
8689 readl(reg); 8689 readl(reg);
8690 write_nic_byte(dev, 0x210014, 0x72); // fifo width =16 8690 write_nic_byte(dev, 0x210014, 0x72); // fifo width =16
8691 readl(reg); 8691 readl(reg);
8692 8692
8693 /* Enable System (Reg 0) 8693 /* Enable System (Reg 0)
8694 * second enable should be OK */ 8694 * second enable should be OK */
8695 write_nic_byte(dev, 0x210000, 0x00); // clear enable system 8695 write_nic_byte(dev, 0x210000, 0x00); // clear enable system
8696 readl(reg); 8696 readl(reg);
8697 write_nic_byte(dev, 0x210000, 0x80); // set enable system 8697 write_nic_byte(dev, 0x210000, 0x80); // set enable system
8698 8698
8699 /* check Symbol is enabled - upped this from 5 as it wasn't always 8699 /* check Symbol is enabled - upped this from 5 as it wasn't always
8700 * catching the update */ 8700 * catching the update */
8701 for (i = 0; i < 10; i++) { 8701 for (i = 0; i < 10; i++) {
8702 udelay(10); 8702 udelay(10);
8703 8703
8704 /* check Dino is enabled bit */ 8704 /* check Dino is enabled bit */
8705 read_nic_byte(dev, 0x210000, &data); 8705 read_nic_byte(dev, 0x210000, &data);
8706 if (data & 0x1) 8706 if (data & 0x1)
8707 break; 8707 break;
8708 } 8708 }
8709 8709
8710 if (i == 10) { 8710 if (i == 10) {
8711 printk(KERN_ERR DRV_NAME ": %s: Error initializing Symbol\n", 8711 printk(KERN_ERR DRV_NAME ": %s: Error initializing Symbol\n",
8712 dev->name); 8712 dev->name);
8713 return -EIO; 8713 return -EIO;
8714 } 8714 }
8715 8715
8716 /* Get Symbol alive response */ 8716 /* Get Symbol alive response */
8717 for (i = 0; i < 30; i++) { 8717 for (i = 0; i < 30; i++) {
8718 /* Read alive response structure */ 8718 /* Read alive response structure */
8719 for (j = 0; 8719 for (j = 0;
8720 j < (sizeof(struct symbol_alive_response) >> 1); j++) 8720 j < (sizeof(struct symbol_alive_response) >> 1); j++)
8721 read_nic_word(dev, 0x210004, ((u16 *) & response) + j); 8721 read_nic_word(dev, 0x210004, ((u16 *) & response) + j);
8722 8722
8723 if ((response.cmd_id == 1) && (response.ucode_valid == 0x1)) 8723 if ((response.cmd_id == 1) && (response.ucode_valid == 0x1))
8724 break; 8724 break;
8725 udelay(10); 8725 udelay(10);
8726 } 8726 }
8727 8727
8728 if (i == 30) { 8728 if (i == 30) {
8729 printk(KERN_ERR DRV_NAME 8729 printk(KERN_ERR DRV_NAME
8730 ": %s: No response from Symbol - hw not alive\n", 8730 ": %s: No response from Symbol - hw not alive\n",
8731 dev->name); 8731 dev->name);
8732 printk_buf(IPW_DL_ERROR, (u8 *) & response, sizeof(response)); 8732 printk_buf(IPW_DL_ERROR, (u8 *) & response, sizeof(response));
8733 return -EIO; 8733 return -EIO;
8734 } 8734 }
8735 8735
8736 return 0; 8736 return 0;
8737 } 8737 }
8738 8738
include/linux/netdevice.h
Diff comments   View file @ cc74998
1 /* 1 /*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX 2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket 3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level. 4 * interface as the means of communication with the user level.
5 * 5 *
6 * Definitions for the Interfaces handler. 6 * Definitions for the Interfaces handler.
7 * 7 *
8 * Version: @(#)dev.h 1.0.10 08/12/93 8 * Version: @(#)dev.h 1.0.10 08/12/93
9 * 9 *
10 * Authors: Ross Biro 10 * Authors: Ross Biro
11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 * Corey Minyard <wf-rch!minyard@relay.EU.net> 12 * Corey Minyard <wf-rch!minyard@relay.EU.net>
13 * Donald J. Becker, <becker@cesdis.gsfc.nasa.gov> 13 * Donald J. Becker, <becker@cesdis.gsfc.nasa.gov>
14 * Alan Cox, <alan@lxorguk.ukuu.org.uk> 14 * Alan Cox, <alan@lxorguk.ukuu.org.uk>
15 * Bjorn Ekwall. <bj0rn@blox.se> 15 * Bjorn Ekwall. <bj0rn@blox.se>
16 * Pekka Riikonen <priikone@poseidon.pspt.fi> 16 * Pekka Riikonen <priikone@poseidon.pspt.fi>
17 * 17 *
18 * This program is free software; you can redistribute it and/or 18 * This program is free software; you can redistribute it and/or
19 * modify it under the terms of the GNU General Public License 19 * modify it under the terms of the GNU General Public License
20 * as published by the Free Software Foundation; either version 20 * as published by the Free Software Foundation; either version
21 * 2 of the License, or (at your option) any later version. 21 * 2 of the License, or (at your option) any later version.
22 * 22 *
23 * Moved to /usr/include/linux for NET3 23 * Moved to /usr/include/linux for NET3
24 */ 24 */
25 #ifndef _LINUX_NETDEVICE_H 25 #ifndef _LINUX_NETDEVICE_H
26 #define _LINUX_NETDEVICE_H 26 #define _LINUX_NETDEVICE_H
27 27
28 #include <linux/if.h> 28 #include <linux/if.h>
29 #include <linux/if_ether.h> 29 #include <linux/if_ether.h>
30 #include <linux/if_packet.h> 30 #include <linux/if_packet.h>
31 #include <linux/if_link.h> 31 #include <linux/if_link.h>
32 32
33 #ifdef __KERNEL__ 33 #ifdef __KERNEL__
34 #include <linux/pm_qos.h> 34 #include <linux/pm_qos.h>
35 #include <linux/timer.h> 35 #include <linux/timer.h>
36 #include <linux/delay.h> 36 #include <linux/delay.h>
37 #include <linux/atomic.h> 37 #include <linux/atomic.h>
38 #include <asm/cache.h> 38 #include <asm/cache.h>
39 #include <asm/byteorder.h> 39 #include <asm/byteorder.h>
40 40
41 #include <linux/device.h> 41 #include <linux/device.h>
42 #include <linux/percpu.h> 42 #include <linux/percpu.h>
43 #include <linux/rculist.h> 43 #include <linux/rculist.h>
44 #include <linux/dmaengine.h> 44 #include <linux/dmaengine.h>
45 #include <linux/workqueue.h> 45 #include <linux/workqueue.h>
46 46
47 #include <linux/ethtool.h> 47 #include <linux/ethtool.h>
48 #include <net/net_namespace.h> 48 #include <net/net_namespace.h>
49 #include <net/dsa.h> 49 #include <net/dsa.h>
50 #ifdef CONFIG_DCB 50 #ifdef CONFIG_DCB
51 #include <net/dcbnl.h> 51 #include <net/dcbnl.h>
52 #endif 52 #endif
53 53
54 struct vlan_group; 54 struct vlan_group;
55 struct netpoll_info; 55 struct netpoll_info;
56 struct phy_device; 56 struct phy_device;
57 /* 802.11 specific */ 57 /* 802.11 specific */
58 struct wireless_dev; 58 struct wireless_dev;
59 /* source back-compat hooks */ 59 /* source back-compat hooks */
60 #define SET_ETHTOOL_OPS(netdev,ops) \ 60 #define SET_ETHTOOL_OPS(netdev,ops) \
61 ( (netdev)->ethtool_ops = (ops) ) 61 ( (netdev)->ethtool_ops = (ops) )
62 62
63 /* hardware address assignment types */ 63 /* hardware address assignment types */
64 #define NET_ADDR_PERM 0 /* address is permanent (default) */ 64 #define NET_ADDR_PERM 0 /* address is permanent (default) */
65 #define NET_ADDR_RANDOM 1 /* address is generated randomly */ 65 #define NET_ADDR_RANDOM 1 /* address is generated randomly */
66 #define NET_ADDR_STOLEN 2 /* address is stolen from other device */ 66 #define NET_ADDR_STOLEN 2 /* address is stolen from other device */
67 67
68 /* Backlog congestion levels */ 68 /* Backlog congestion levels */
69 #define NET_RX_SUCCESS 0 /* keep 'em coming, baby */ 69 #define NET_RX_SUCCESS 0 /* keep 'em coming, baby */
70 #define NET_RX_DROP 1 /* packet dropped */ 70 #define NET_RX_DROP 1 /* packet dropped */
71 71
72 /* 72 /*
73 * Transmit return codes: transmit return codes originate from three different 73 * Transmit return codes: transmit return codes originate from three different
74 * namespaces: 74 * namespaces:
75 * 75 *
76 * - qdisc return codes 76 * - qdisc return codes
77 * - driver transmit return codes 77 * - driver transmit return codes
78 * - errno values 78 * - errno values
79 * 79 *
80 * Drivers are allowed to return any one of those in their hard_start_xmit() 80 * Drivers are allowed to return any one of those in their hard_start_xmit()
81 * function. Real network devices commonly used with qdiscs should only return 81 * function. Real network devices commonly used with qdiscs should only return
82 * the driver transmit return codes though - when qdiscs are used, the actual 82 * the driver transmit return codes though - when qdiscs are used, the actual
83 * transmission happens asynchronously, so the value is not propagated to 83 * transmission happens asynchronously, so the value is not propagated to
84 * higher layers. Virtual network devices transmit synchronously, in this case 84 * higher layers. Virtual network devices transmit synchronously, in this case
85 * the driver transmit return codes are consumed by dev_queue_xmit(), all 85 * the driver transmit return codes are consumed by dev_queue_xmit(), all
86 * others are propagated to higher layers. 86 * others are propagated to higher layers.
87 */ 87 */
88 88
89 /* qdisc ->enqueue() return codes. */ 89 /* qdisc ->enqueue() return codes. */
90 #define NET_XMIT_SUCCESS 0x00 90 #define NET_XMIT_SUCCESS 0x00
91 #define NET_XMIT_DROP 0x01 /* skb dropped */ 91 #define NET_XMIT_DROP 0x01 /* skb dropped */
92 #define NET_XMIT_CN 0x02 /* congestion notification */ 92 #define NET_XMIT_CN 0x02 /* congestion notification */
93 #define NET_XMIT_POLICED 0x03 /* skb is shot by police */ 93 #define NET_XMIT_POLICED 0x03 /* skb is shot by police */
94 #define NET_XMIT_MASK 0x0f /* qdisc flags in net/sch_generic.h */ 94 #define NET_XMIT_MASK 0x0f /* qdisc flags in net/sch_generic.h */
95 95
96 /* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It 96 /* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It
97 * indicates that the device will soon be dropping packets, or already drops 97 * indicates that the device will soon be dropping packets, or already drops
98 * some packets of the same priority; prompting us to send less aggressively. */ 98 * some packets of the same priority; prompting us to send less aggressively. */
99 #define net_xmit_eval(e) ((e) == NET_XMIT_CN ? 0 : (e)) 99 #define net_xmit_eval(e) ((e) == NET_XMIT_CN ? 0 : (e))
100 #define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0) 100 #define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
101 101
102 /* Driver transmit return codes */ 102 /* Driver transmit return codes */
103 #define NETDEV_TX_MASK 0xf0 103 #define NETDEV_TX_MASK 0xf0
104 104
105 enum netdev_tx { 105 enum netdev_tx {
106 __NETDEV_TX_MIN = INT_MIN, /* make sure enum is signed */ 106 __NETDEV_TX_MIN = INT_MIN, /* make sure enum is signed */
107 NETDEV_TX_OK = 0x00, /* driver took care of packet */ 107 NETDEV_TX_OK = 0x00, /* driver took care of packet */
108 NETDEV_TX_BUSY = 0x10, /* driver tx path was busy*/ 108 NETDEV_TX_BUSY = 0x10, /* driver tx path was busy*/
109 NETDEV_TX_LOCKED = 0x20, /* driver tx lock was already taken */ 109 NETDEV_TX_LOCKED = 0x20, /* driver tx lock was already taken */
110 }; 110 };
111 typedef enum netdev_tx netdev_tx_t; 111 typedef enum netdev_tx netdev_tx_t;
112 112
113 /* 113 /*
114 * Current order: NETDEV_TX_MASK > NET_XMIT_MASK >= 0 is significant; 114 * Current order: NETDEV_TX_MASK > NET_XMIT_MASK >= 0 is significant;
115 * hard_start_xmit() return < NET_XMIT_MASK means skb was consumed. 115 * hard_start_xmit() return < NET_XMIT_MASK means skb was consumed.
116 */ 116 */
117 static inline bool dev_xmit_complete(int rc) 117 static inline bool dev_xmit_complete(int rc)
118 { 118 {
119 /* 119 /*
120 * Positive cases with an skb consumed by a driver: 120 * Positive cases with an skb consumed by a driver:
121 * - successful transmission (rc == NETDEV_TX_OK) 121 * - successful transmission (rc == NETDEV_TX_OK)
122 * - error while transmitting (rc < 0) 122 * - error while transmitting (rc < 0)
123 * - error while queueing to a different device (rc & NET_XMIT_MASK) 123 * - error while queueing to a different device (rc & NET_XMIT_MASK)
124 */ 124 */
125 if (likely(rc < NET_XMIT_MASK)) 125 if (likely(rc < NET_XMIT_MASK))
126 return true; 126 return true;
127 127
128 return false; 128 return false;
129 } 129 }
130 130
131 #endif 131 #endif
132 132
133 #define MAX_ADDR_LEN 32 /* Largest hardware address length */ 133 #define MAX_ADDR_LEN 32 /* Largest hardware address length */
134 134
135 /* Initial net device group. All devices belong to group 0 by default. */ 135 /* Initial net device group. All devices belong to group 0 by default. */
136 #define INIT_NETDEV_GROUP 0 136 #define INIT_NETDEV_GROUP 0
137 137
138 #ifdef __KERNEL__ 138 #ifdef __KERNEL__
139 /* 139 /*
140 * Compute the worst case header length according to the protocols 140 * Compute the worst case header length according to the protocols
141 * used. 141 * used.
142 */ 142 */
143 143
144 #if defined(CONFIG_WLAN) || defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE) 144 #if defined(CONFIG_WLAN) || defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
145 # if defined(CONFIG_MAC80211_MESH) 145 # if defined(CONFIG_MAC80211_MESH)
146 # define LL_MAX_HEADER 128 146 # define LL_MAX_HEADER 128
147 # else 147 # else
148 # define LL_MAX_HEADER 96 148 # define LL_MAX_HEADER 96
149 # endif 149 # endif
150 #elif defined(CONFIG_TR) || defined(CONFIG_TR_MODULE) 150 #elif defined(CONFIG_TR) || defined(CONFIG_TR_MODULE)
151 # define LL_MAX_HEADER 48 151 # define LL_MAX_HEADER 48
152 #else 152 #else
153 # define LL_MAX_HEADER 32 153 # define LL_MAX_HEADER 32
154 #endif 154 #endif
155 155
156 #if !defined(CONFIG_NET_IPIP) && !defined(CONFIG_NET_IPIP_MODULE) && \ 156 #if !defined(CONFIG_NET_IPIP) && !defined(CONFIG_NET_IPIP_MODULE) && \
157 !defined(CONFIG_NET_IPGRE) && !defined(CONFIG_NET_IPGRE_MODULE) && \ 157 !defined(CONFIG_NET_IPGRE) && !defined(CONFIG_NET_IPGRE_MODULE) && \
158 !defined(CONFIG_IPV6_SIT) && !defined(CONFIG_IPV6_SIT_MODULE) && \ 158 !defined(CONFIG_IPV6_SIT) && !defined(CONFIG_IPV6_SIT_MODULE) && \
159 !defined(CONFIG_IPV6_TUNNEL) && !defined(CONFIG_IPV6_TUNNEL_MODULE) 159 !defined(CONFIG_IPV6_TUNNEL) && !defined(CONFIG_IPV6_TUNNEL_MODULE)
160 #define MAX_HEADER LL_MAX_HEADER 160 #define MAX_HEADER LL_MAX_HEADER
161 #else 161 #else
162 #define MAX_HEADER (LL_MAX_HEADER + 48) 162 #define MAX_HEADER (LL_MAX_HEADER + 48)
163 #endif 163 #endif
164 164
165 /* 165 /*
166 * Old network device statistics. Fields are native words 166 * Old network device statistics. Fields are native words
167 * (unsigned long) so they can be read and written atomically. 167 * (unsigned long) so they can be read and written atomically.
168 */ 168 */
169 169
170 struct net_device_stats { 170 struct net_device_stats {
171 unsigned long rx_packets; 171 unsigned long rx_packets;
172 unsigned long tx_packets; 172 unsigned long tx_packets;
173 unsigned long rx_bytes; 173 unsigned long rx_bytes;
174 unsigned long tx_bytes; 174 unsigned long tx_bytes;
175 unsigned long rx_errors; 175 unsigned long rx_errors;
176 unsigned long tx_errors; 176 unsigned long tx_errors;
177 unsigned long rx_dropped; 177 unsigned long rx_dropped;
178 unsigned long tx_dropped; 178 unsigned long tx_dropped;
179 unsigned long multicast; 179 unsigned long multicast;
180 unsigned long collisions; 180 unsigned long collisions;
181 unsigned long rx_length_errors; 181 unsigned long rx_length_errors;
182 unsigned long rx_over_errors; 182 unsigned long rx_over_errors;
183 unsigned long rx_crc_errors; 183 unsigned long rx_crc_errors;
184 unsigned long rx_frame_errors; 184 unsigned long rx_frame_errors;
185 unsigned long rx_fifo_errors; 185 unsigned long rx_fifo_errors;
186 unsigned long rx_missed_errors; 186 unsigned long rx_missed_errors;
187 unsigned long tx_aborted_errors; 187 unsigned long tx_aborted_errors;
188 unsigned long tx_carrier_errors; 188 unsigned long tx_carrier_errors;
189 unsigned long tx_fifo_errors; 189 unsigned long tx_fifo_errors;
190 unsigned long tx_heartbeat_errors; 190 unsigned long tx_heartbeat_errors;
191 unsigned long tx_window_errors; 191 unsigned long tx_window_errors;
192 unsigned long rx_compressed; 192 unsigned long rx_compressed;
193 unsigned long tx_compressed; 193 unsigned long tx_compressed;
194 }; 194 };
195 195
196 #endif /* __KERNEL__ */ 196 #endif /* __KERNEL__ */
197 197
198 198
199 /* Media selection options. */ 199 /* Media selection options. */
200 enum { 200 enum {
201 IF_PORT_UNKNOWN = 0, 201 IF_PORT_UNKNOWN = 0,
202 IF_PORT_10BASE2, 202 IF_PORT_10BASE2,
203 IF_PORT_10BASET, 203 IF_PORT_10BASET,
204 IF_PORT_AUI, 204 IF_PORT_AUI,
205 IF_PORT_100BASET, 205 IF_PORT_100BASET,
206 IF_PORT_100BASETX, 206 IF_PORT_100BASETX,
207 IF_PORT_100BASEFX 207 IF_PORT_100BASEFX
208 }; 208 };
209 209
210 #ifdef __KERNEL__ 210 #ifdef __KERNEL__
211 211
212 #include <linux/cache.h> 212 #include <linux/cache.h>
213 #include <linux/skbuff.h> 213 #include <linux/skbuff.h>
214 214
215 struct neighbour; 215 struct neighbour;
216 struct neigh_parms; 216 struct neigh_parms;
217 struct sk_buff; 217 struct sk_buff;
218 218
219 struct netdev_hw_addr { 219 struct netdev_hw_addr {
220 struct list_head list; 220 struct list_head list;
221 unsigned char addr[MAX_ADDR_LEN]; 221 unsigned char addr[MAX_ADDR_LEN];
222 unsigned char type; 222 unsigned char type;
223 #define NETDEV_HW_ADDR_T_LAN 1 223 #define NETDEV_HW_ADDR_T_LAN 1
224 #define NETDEV_HW_ADDR_T_SAN 2 224 #define NETDEV_HW_ADDR_T_SAN 2
225 #define NETDEV_HW_ADDR_T_SLAVE 3 225 #define NETDEV_HW_ADDR_T_SLAVE 3
226 #define NETDEV_HW_ADDR_T_UNICAST 4 226 #define NETDEV_HW_ADDR_T_UNICAST 4
227 #define NETDEV_HW_ADDR_T_MULTICAST 5 227 #define NETDEV_HW_ADDR_T_MULTICAST 5
228 bool synced; 228 bool synced;
229 bool global_use; 229 bool global_use;
230 int refcount; 230 int refcount;
231 struct rcu_head rcu_head; 231 struct rcu_head rcu_head;
232 }; 232 };
233 233
234 struct netdev_hw_addr_list { 234 struct netdev_hw_addr_list {
235 struct list_head list; 235 struct list_head list;
236 int count; 236 int count;
237 }; 237 };
238 238
239 #define netdev_hw_addr_list_count(l) ((l)->count) 239 #define netdev_hw_addr_list_count(l) ((l)->count)
240 #define netdev_hw_addr_list_empty(l) (netdev_hw_addr_list_count(l) == 0) 240 #define netdev_hw_addr_list_empty(l) (netdev_hw_addr_list_count(l) == 0)
241 #define netdev_hw_addr_list_for_each(ha, l) \ 241 #define netdev_hw_addr_list_for_each(ha, l) \
242 list_for_each_entry(ha, &(l)->list, list) 242 list_for_each_entry(ha, &(l)->list, list)
243 243
244 #define netdev_uc_count(dev) netdev_hw_addr_list_count(&(dev)->uc) 244 #define netdev_uc_count(dev) netdev_hw_addr_list_count(&(dev)->uc)
245 #define netdev_uc_empty(dev) netdev_hw_addr_list_empty(&(dev)->uc) 245 #define netdev_uc_empty(dev) netdev_hw_addr_list_empty(&(dev)->uc)
246 #define netdev_for_each_uc_addr(ha, dev) \ 246 #define netdev_for_each_uc_addr(ha, dev) \
247 netdev_hw_addr_list_for_each(ha, &(dev)->uc) 247 netdev_hw_addr_list_for_each(ha, &(dev)->uc)
248 248
249 #define netdev_mc_count(dev) netdev_hw_addr_list_count(&(dev)->mc) 249 #define netdev_mc_count(dev) netdev_hw_addr_list_count(&(dev)->mc)
250 #define netdev_mc_empty(dev) netdev_hw_addr_list_empty(&(dev)->mc) 250 #define netdev_mc_empty(dev) netdev_hw_addr_list_empty(&(dev)->mc)
251 #define netdev_for_each_mc_addr(ha, dev) \ 251 #define netdev_for_each_mc_addr(ha, dev) \
252 netdev_hw_addr_list_for_each(ha, &(dev)->mc) 252 netdev_hw_addr_list_for_each(ha, &(dev)->mc)
253 253
254 struct hh_cache { 254 struct hh_cache {
255 u16 hh_len; 255 u16 hh_len;
256 u16 __pad; 256 u16 __pad;
257 seqlock_t hh_lock; 257 seqlock_t hh_lock;
258 258
259 /* cached hardware header; allow for machine alignment needs. */ 259 /* cached hardware header; allow for machine alignment needs. */
260 #define HH_DATA_MOD 16 260 #define HH_DATA_MOD 16
261 #define HH_DATA_OFF(__len) \ 261 #define HH_DATA_OFF(__len) \
262 (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1)) 262 (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
263 #define HH_DATA_ALIGN(__len) \ 263 #define HH_DATA_ALIGN(__len) \
264 (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1)) 264 (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
265 unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)]; 265 unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
266 }; 266 };
267 267
268 /* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much. 268 /* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
269 * Alternative is: 269 * Alternative is:
270 * dev->hard_header_len ? (dev->hard_header_len + 270 * dev->hard_header_len ? (dev->hard_header_len +
271 * (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0 271 * (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
272 * 272 *
273 * We could use other alignment values, but we must maintain the 273 * We could use other alignment values, but we must maintain the
274 * relationship HH alignment <= LL alignment. 274 * relationship HH alignment <= LL alignment.
275 * 275 *
276 * LL_ALLOCATED_SPACE also takes into account the tailroom the device 276 * LL_ALLOCATED_SPACE also takes into account the tailroom the device
277 * may need. 277 * may need.
278 */ 278 */
279 #define LL_RESERVED_SPACE(dev) \ 279 #define LL_RESERVED_SPACE(dev) \
280 ((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD) 280 ((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
281 #define LL_RESERVED_SPACE_EXTRA(dev,extra) \ 281 #define LL_RESERVED_SPACE_EXTRA(dev,extra) \
282 ((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD) 282 ((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
283 #define LL_ALLOCATED_SPACE(dev) \ 283 #define LL_ALLOCATED_SPACE(dev) \
284 ((((dev)->hard_header_len+(dev)->needed_headroom+(dev)->needed_tailroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD) 284 ((((dev)->hard_header_len+(dev)->needed_headroom+(dev)->needed_tailroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
285 285
286 struct header_ops { 286 struct header_ops {
287 int (*create) (struct sk_buff *skb, struct net_device *dev, 287 int (*create) (struct sk_buff *skb, struct net_device *dev,
288 unsigned short type, const void *daddr, 288 unsigned short type, const void *daddr,
289 const void *saddr, unsigned len); 289 const void *saddr, unsigned len);
290 int (*parse)(const struct sk_buff *skb, unsigned char *haddr); 290 int (*parse)(const struct sk_buff *skb, unsigned char *haddr);
291 int (*rebuild)(struct sk_buff *skb); 291 int (*rebuild)(struct sk_buff *skb);
292 int (*cache)(const struct neighbour *neigh, struct hh_cache *hh, __be16 type); 292 int (*cache)(const struct neighbour *neigh, struct hh_cache *hh, __be16 type);
293 void (*cache_update)(struct hh_cache *hh, 293 void (*cache_update)(struct hh_cache *hh,
294 const struct net_device *dev, 294 const struct net_device *dev,
295 const unsigned char *haddr); 295 const unsigned char *haddr);
296 }; 296 };
297 297
298 /* These flag bits are private to the generic network queueing 298 /* These flag bits are private to the generic network queueing
299 * layer, they may not be explicitly referenced by any other 299 * layer, they may not be explicitly referenced by any other
300 * code. 300 * code.
301 */ 301 */
302 302
303 enum netdev_state_t { 303 enum netdev_state_t {
304 __LINK_STATE_START, 304 __LINK_STATE_START,
305 __LINK_STATE_PRESENT, 305 __LINK_STATE_PRESENT,
306 __LINK_STATE_NOCARRIER, 306 __LINK_STATE_NOCARRIER,
307 __LINK_STATE_LINKWATCH_PENDING, 307 __LINK_STATE_LINKWATCH_PENDING,
308 __LINK_STATE_DORMANT, 308 __LINK_STATE_DORMANT,
309 }; 309 };
310 310
311 311
312 /* 312 /*
313 * This structure holds at boot time configured netdevice settings. They 313 * This structure holds at boot time configured netdevice settings. They
314 * are then used in the device probing. 314 * are then used in the device probing.
315 */ 315 */
316 struct netdev_boot_setup { 316 struct netdev_boot_setup {
317 char name[IFNAMSIZ]; 317 char name[IFNAMSIZ];
318 struct ifmap map; 318 struct ifmap map;
319 }; 319 };
320 #define NETDEV_BOOT_SETUP_MAX 8 320 #define NETDEV_BOOT_SETUP_MAX 8
321 321
322 extern int __init netdev_boot_setup(char *str); 322 extern int __init netdev_boot_setup(char *str);
323 323
324 /* 324 /*
325 * Structure for NAPI scheduling similar to tasklet but with weighting 325 * Structure for NAPI scheduling similar to tasklet but with weighting
326 */ 326 */
327 struct napi_struct { 327 struct napi_struct {
328 /* The poll_list must only be managed by the entity which 328 /* The poll_list must only be managed by the entity which
329 * changes the state of the NAPI_STATE_SCHED bit. This means 329 * changes the state of the NAPI_STATE_SCHED bit. This means
330 * whoever atomically sets that bit can add this napi_struct 330 * whoever atomically sets that bit can add this napi_struct
331 * to the per-cpu poll_list, and whoever clears that bit 331 * to the per-cpu poll_list, and whoever clears that bit
332 * can remove from the list right before clearing the bit. 332 * can remove from the list right before clearing the bit.
333 */ 333 */
334 struct list_head poll_list; 334 struct list_head poll_list;
335 335
336 unsigned long state; 336 unsigned long state;
337 int weight; 337 int weight;
338 int (*poll)(struct napi_struct *, int); 338 int (*poll)(struct napi_struct *, int);
339 #ifdef CONFIG_NETPOLL 339 #ifdef CONFIG_NETPOLL
340 spinlock_t poll_lock; 340 spinlock_t poll_lock;
341 int poll_owner; 341 int poll_owner;
342 #endif 342 #endif
343 343
344 unsigned int gro_count; 344 unsigned int gro_count;
345 345
346 struct net_device *dev; 346 struct net_device *dev;
347 struct list_head dev_list; 347 struct list_head dev_list;
348 struct sk_buff *gro_list; 348 struct sk_buff *gro_list;
349 struct sk_buff *skb; 349 struct sk_buff *skb;
350 }; 350 };
351 351
352 enum { 352 enum {
353 NAPI_STATE_SCHED, /* Poll is scheduled */ 353 NAPI_STATE_SCHED, /* Poll is scheduled */
354 NAPI_STATE_DISABLE, /* Disable pending */ 354 NAPI_STATE_DISABLE, /* Disable pending */
355 NAPI_STATE_NPSVC, /* Netpoll - don't dequeue from poll_list */ 355 NAPI_STATE_NPSVC, /* Netpoll - don't dequeue from poll_list */
356 }; 356 };
357 357
358 enum gro_result { 358 enum gro_result {
359 GRO_MERGED, 359 GRO_MERGED,
360 GRO_MERGED_FREE, 360 GRO_MERGED_FREE,
361 GRO_HELD, 361 GRO_HELD,
362 GRO_NORMAL, 362 GRO_NORMAL,
363 GRO_DROP, 363 GRO_DROP,
364 }; 364 };
365 typedef enum gro_result gro_result_t; 365 typedef enum gro_result gro_result_t;
366 366
367 /* 367 /*
368 * enum rx_handler_result - Possible return values for rx_handlers. 368 * enum rx_handler_result - Possible return values for rx_handlers.
369 * @RX_HANDLER_CONSUMED: skb was consumed by rx_handler, do not process it 369 * @RX_HANDLER_CONSUMED: skb was consumed by rx_handler, do not process it
370 * further. 370 * further.
371 * @RX_HANDLER_ANOTHER: Do another round in receive path. This is indicated in 371 * @RX_HANDLER_ANOTHER: Do another round in receive path. This is indicated in
372 * case skb->dev was changed by rx_handler. 372 * case skb->dev was changed by rx_handler.
373 * @RX_HANDLER_EXACT: Force exact delivery, no wildcard. 373 * @RX_HANDLER_EXACT: Force exact delivery, no wildcard.
374 * @RX_HANDLER_PASS: Do nothing, passe the skb as if no rx_handler was called. 374 * @RX_HANDLER_PASS: Do nothing, passe the skb as if no rx_handler was called.
375 * 375 *
376 * rx_handlers are functions called from inside __netif_receive_skb(), to do 376 * rx_handlers are functions called from inside __netif_receive_skb(), to do
377 * special processing of the skb, prior to delivery to protocol handlers. 377 * special processing of the skb, prior to delivery to protocol handlers.
378 * 378 *
379 * Currently, a net_device can only have a single rx_handler registered. Trying 379 * Currently, a net_device can only have a single rx_handler registered. Trying
380 * to register a second rx_handler will return -EBUSY. 380 * to register a second rx_handler will return -EBUSY.
381 * 381 *
382 * To register a rx_handler on a net_device, use netdev_rx_handler_register(). 382 * To register a rx_handler on a net_device, use netdev_rx_handler_register().
383 * To unregister a rx_handler on a net_device, use 383 * To unregister a rx_handler on a net_device, use
384 * netdev_rx_handler_unregister(). 384 * netdev_rx_handler_unregister().
385 * 385 *
386 * Upon return, rx_handler is expected to tell __netif_receive_skb() what to 386 * Upon return, rx_handler is expected to tell __netif_receive_skb() what to
387 * do with the skb. 387 * do with the skb.
388 * 388 *
389 * If the rx_handler consumed to skb in some way, it should return 389 * If the rx_handler consumed to skb in some way, it should return
390 * RX_HANDLER_CONSUMED. This is appropriate when the rx_handler arranged for 390 * RX_HANDLER_CONSUMED. This is appropriate when the rx_handler arranged for
391 * the skb to be delivered in some other ways. 391 * the skb to be delivered in some other ways.
392 * 392 *
393 * If the rx_handler changed skb->dev, to divert the skb to another 393 * If the rx_handler changed skb->dev, to divert the skb to another
394 * net_device, it should return RX_HANDLER_ANOTHER. The rx_handler for the 394 * net_device, it should return RX_HANDLER_ANOTHER. The rx_handler for the
395 * new device will be called if it exists. 395 * new device will be called if it exists.
396 * 396 *
397 * If the rx_handler consider the skb should be ignored, it should return 397 * If the rx_handler consider the skb should be ignored, it should return
398 * RX_HANDLER_EXACT. The skb will only be delivered to protocol handlers that 398 * RX_HANDLER_EXACT. The skb will only be delivered to protocol handlers that
399 * are registred on exact device (ptype->dev == skb->dev). 399 * are registred on exact device (ptype->dev == skb->dev).
400 * 400 *
401 * If the rx_handler didn't changed skb->dev, but want the skb to be normally 401 * If the rx_handler didn't changed skb->dev, but want the skb to be normally
402 * delivered, it should return RX_HANDLER_PASS. 402 * delivered, it should return RX_HANDLER_PASS.
403 * 403 *
404 * A device without a registered rx_handler will behave as if rx_handler 404 * A device without a registered rx_handler will behave as if rx_handler
405 * returned RX_HANDLER_PASS. 405 * returned RX_HANDLER_PASS.
406 */ 406 */
407 407
408 enum rx_handler_result { 408 enum rx_handler_result {
409 RX_HANDLER_CONSUMED, 409 RX_HANDLER_CONSUMED,
410 RX_HANDLER_ANOTHER, 410 RX_HANDLER_ANOTHER,
411 RX_HANDLER_EXACT, 411 RX_HANDLER_EXACT,
412 RX_HANDLER_PASS, 412 RX_HANDLER_PASS,
413 }; 413 };
414 typedef enum rx_handler_result rx_handler_result_t; 414 typedef enum rx_handler_result rx_handler_result_t;
415 typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **pskb); 415 typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **pskb);
416 416
417 extern void __napi_schedule(struct napi_struct *n); 417 extern void __napi_schedule(struct napi_struct *n);
418 418
419 static inline int napi_disable_pending(struct napi_struct *n) 419 static inline int napi_disable_pending(struct napi_struct *n)
420 { 420 {
421 return test_bit(NAPI_STATE_DISABLE, &n->state); 421 return test_bit(NAPI_STATE_DISABLE, &n->state);
422 } 422 }
423 423
424 /** 424 /**
425 * napi_schedule_prep - check if napi can be scheduled 425 * napi_schedule_prep - check if napi can be scheduled
426 * @n: napi context 426 * @n: napi context
427 * 427 *
428 * Test if NAPI routine is already running, and if not mark 428 * Test if NAPI routine is already running, and if not mark
429 * it as running. This is used as a condition variable 429 * it as running. This is used as a condition variable
430 * insure only one NAPI poll instance runs. We also make 430 * insure only one NAPI poll instance runs. We also make
431 * sure there is no pending NAPI disable. 431 * sure there is no pending NAPI disable.
432 */ 432 */
433 static inline int napi_schedule_prep(struct napi_struct *n) 433 static inline int napi_schedule_prep(struct napi_struct *n)
434 { 434 {
435 return !napi_disable_pending(n) && 435 return !napi_disable_pending(n) &&
436 !test_and_set_bit(NAPI_STATE_SCHED, &n->state); 436 !test_and_set_bit(NAPI_STATE_SCHED, &n->state);
437 } 437 }
438 438
439 /** 439 /**
440 * napi_schedule - schedule NAPI poll 440 * napi_schedule - schedule NAPI poll
441 * @n: napi context 441 * @n: napi context
442 * 442 *
443 * Schedule NAPI poll routine to be called if it is not already 443 * Schedule NAPI poll routine to be called if it is not already
444 * running. 444 * running.
445 */ 445 */
446 static inline void napi_schedule(struct napi_struct *n) 446 static inline void napi_schedule(struct napi_struct *n)
447 { 447 {
448 if (napi_schedule_prep(n)) 448 if (napi_schedule_prep(n))
449 __napi_schedule(n); 449 __napi_schedule(n);
450 } 450 }
451 451
452 /* Try to reschedule poll. Called by dev->poll() after napi_complete(). */ 452 /* Try to reschedule poll. Called by dev->poll() after napi_complete(). */
453 static inline int napi_reschedule(struct napi_struct *napi) 453 static inline int napi_reschedule(struct napi_struct *napi)
454 { 454 {
455 if (napi_schedule_prep(napi)) { 455 if (napi_schedule_prep(napi)) {
456 __napi_schedule(napi); 456 __napi_schedule(napi);
457 return 1; 457 return 1;
458 } 458 }
459 return 0; 459 return 0;
460 } 460 }
461 461
462 /** 462 /**
463 * napi_complete - NAPI processing complete 463 * napi_complete - NAPI processing complete
464 * @n: napi context 464 * @n: napi context
465 * 465 *
466 * Mark NAPI processing as complete. 466 * Mark NAPI processing as complete.
467 */ 467 */
468 extern void __napi_complete(struct napi_struct *n); 468 extern void __napi_complete(struct napi_struct *n);
469 extern void napi_complete(struct napi_struct *n); 469 extern void napi_complete(struct napi_struct *n);
470 470
471 /** 471 /**
472 * napi_disable - prevent NAPI from scheduling 472 * napi_disable - prevent NAPI from scheduling
473 * @n: napi context 473 * @n: napi context
474 * 474 *
475 * Stop NAPI from being scheduled on this context. 475 * Stop NAPI from being scheduled on this context.
476 * Waits till any outstanding processing completes. 476 * Waits till any outstanding processing completes.
477 */ 477 */
478 static inline void napi_disable(struct napi_struct *n) 478 static inline void napi_disable(struct napi_struct *n)
479 { 479 {
480 set_bit(NAPI_STATE_DISABLE, &n->state); 480 set_bit(NAPI_STATE_DISABLE, &n->state);
481 while (test_and_set_bit(NAPI_STATE_SCHED, &n->state)) 481 while (test_and_set_bit(NAPI_STATE_SCHED, &n->state))
482 msleep(1); 482 msleep(1);
483 clear_bit(NAPI_STATE_DISABLE, &n->state); 483 clear_bit(NAPI_STATE_DISABLE, &n->state);
484 } 484 }
485 485
486 /** 486 /**
487 * napi_enable - enable NAPI scheduling 487 * napi_enable - enable NAPI scheduling
488 * @n: napi context 488 * @n: napi context
489 * 489 *
490 * Resume NAPI from being scheduled on this context. 490 * Resume NAPI from being scheduled on this context.
491 * Must be paired with napi_disable. 491 * Must be paired with napi_disable.
492 */ 492 */
493 static inline void napi_enable(struct napi_struct *n) 493 static inline void napi_enable(struct napi_struct *n)
494 { 494 {
495 BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state)); 495 BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
496 smp_mb__before_clear_bit(); 496 smp_mb__before_clear_bit();
497 clear_bit(NAPI_STATE_SCHED, &n->state); 497 clear_bit(NAPI_STATE_SCHED, &n->state);
498 } 498 }
499 499
500 #ifdef CONFIG_SMP 500 #ifdef CONFIG_SMP
501 /** 501 /**
502 * napi_synchronize - wait until NAPI is not running 502 * napi_synchronize - wait until NAPI is not running
503 * @n: napi context 503 * @n: napi context
504 * 504 *
505 * Wait until NAPI is done being scheduled on this context. 505 * Wait until NAPI is done being scheduled on this context.
506 * Waits till any outstanding processing completes but 506 * Waits till any outstanding processing completes but
507 * does not disable future activations. 507 * does not disable future activations.
508 */ 508 */
509 static inline void napi_synchronize(const struct napi_struct *n) 509 static inline void napi_synchronize(const struct napi_struct *n)
510 { 510 {
511 while (test_bit(NAPI_STATE_SCHED, &n->state)) 511 while (test_bit(NAPI_STATE_SCHED, &n->state))
512 msleep(1); 512 msleep(1);
513 } 513 }
514 #else 514 #else
515 # define napi_synchronize(n) barrier() 515 # define napi_synchronize(n) barrier()
516 #endif 516 #endif
517 517
518 enum netdev_queue_state_t { 518 enum netdev_queue_state_t {
519 __QUEUE_STATE_XOFF, 519 __QUEUE_STATE_XOFF,
520 __QUEUE_STATE_FROZEN, 520 __QUEUE_STATE_FROZEN,
521 #define QUEUE_STATE_XOFF_OR_FROZEN ((1 << __QUEUE_STATE_XOFF) | \ 521 #define QUEUE_STATE_XOFF_OR_FROZEN ((1 << __QUEUE_STATE_XOFF) | \
522 (1 << __QUEUE_STATE_FROZEN)) 522 (1 << __QUEUE_STATE_FROZEN))
523 }; 523 };
524 524
525 struct netdev_queue { 525 struct netdev_queue {
526 /* 526 /*
527 * read mostly part 527 * read mostly part
528 */ 528 */
529 struct net_device *dev; 529 struct net_device *dev;
530 struct Qdisc *qdisc; 530 struct Qdisc *qdisc;
531 unsigned long state; 531 unsigned long state;
532 struct Qdisc *qdisc_sleeping; 532 struct Qdisc *qdisc_sleeping;
533 #if defined(CONFIG_RPS) || defined(CONFIG_XPS) 533 #if defined(CONFIG_RPS) || defined(CONFIG_XPS)
534 struct kobject kobj; 534 struct kobject kobj;
535 #endif 535 #endif
536 #if defined(CONFIG_XPS) && defined(CONFIG_NUMA) 536 #if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
537 int numa_node; 537 int numa_node;
538 #endif 538 #endif
539 /* 539 /*
540 * write mostly part 540 * write mostly part
541 */ 541 */
542 spinlock_t _xmit_lock ____cacheline_aligned_in_smp; 542 spinlock_t _xmit_lock ____cacheline_aligned_in_smp;
543 int xmit_lock_owner; 543 int xmit_lock_owner;
544 /* 544 /*
545 * please use this field instead of dev->trans_start 545 * please use this field instead of dev->trans_start
546 */ 546 */
547 unsigned long trans_start; 547 unsigned long trans_start;
548 } ____cacheline_aligned_in_smp; 548 } ____cacheline_aligned_in_smp;
549 549
550 static inline int netdev_queue_numa_node_read(const struct netdev_queue *q) 550 static inline int netdev_queue_numa_node_read(const struct netdev_queue *q)
551 { 551 {
552 #if defined(CONFIG_XPS) && defined(CONFIG_NUMA) 552 #if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
553 return q->numa_node; 553 return q->numa_node;
554 #else 554 #else
555 return NUMA_NO_NODE; 555 return NUMA_NO_NODE;
556 #endif 556 #endif
557 } 557 }
558 558
559 static inline void netdev_queue_numa_node_write(struct netdev_queue *q, int node) 559 static inline void netdev_queue_numa_node_write(struct netdev_queue *q, int node)
560 { 560 {
561 #if defined(CONFIG_XPS) && defined(CONFIG_NUMA) 561 #if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
562 q->numa_node = node; 562 q->numa_node = node;
563 #endif 563 #endif
564 } 564 }
565 565
566 #ifdef CONFIG_RPS 566 #ifdef CONFIG_RPS
567 /* 567 /*
568 * This structure holds an RPS map which can be of variable length. The 568 * This structure holds an RPS map which can be of variable length. The
569 * map is an array of CPUs. 569 * map is an array of CPUs.
570 */ 570 */
571 struct rps_map { 571 struct rps_map {
572 unsigned int len; 572 unsigned int len;
573 struct rcu_head rcu; 573 struct rcu_head rcu;
574 u16 cpus[0]; 574 u16 cpus[0];
575 }; 575 };
576 #define RPS_MAP_SIZE(_num) (sizeof(struct rps_map) + (_num * sizeof(u16))) 576 #define RPS_MAP_SIZE(_num) (sizeof(struct rps_map) + (_num * sizeof(u16)))
577 577
578 /* 578 /*
579 * The rps_dev_flow structure contains the mapping of a flow to a CPU, the 579 * The rps_dev_flow structure contains the mapping of a flow to a CPU, the
580 * tail pointer for that CPU's input queue at the time of last enqueue, and 580 * tail pointer for that CPU's input queue at the time of last enqueue, and
581 * a hardware filter index. 581 * a hardware filter index.
582 */ 582 */
583 struct rps_dev_flow { 583 struct rps_dev_flow {
584 u16 cpu; 584 u16 cpu;
585 u16 filter; 585 u16 filter;
586 unsigned int last_qtail; 586 unsigned int last_qtail;
587 }; 587 };
588 #define RPS_NO_FILTER 0xffff 588 #define RPS_NO_FILTER 0xffff
589 589
590 /* 590 /*
591 * The rps_dev_flow_table structure contains a table of flow mappings. 591 * The rps_dev_flow_table structure contains a table of flow mappings.
592 */ 592 */
593 struct rps_dev_flow_table { 593 struct rps_dev_flow_table {
594 unsigned int mask; 594 unsigned int mask;
595 struct rcu_head rcu; 595 struct rcu_head rcu;
596 struct work_struct free_work; 596 struct work_struct free_work;
597 struct rps_dev_flow flows[0]; 597 struct rps_dev_flow flows[0];
598 }; 598 };
599 #define RPS_DEV_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_dev_flow_table) + \ 599 #define RPS_DEV_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_dev_flow_table) + \
600 (_num * sizeof(struct rps_dev_flow))) 600 (_num * sizeof(struct rps_dev_flow)))
601 601
602 /* 602 /*
603 * The rps_sock_flow_table contains mappings of flows to the last CPU 603 * The rps_sock_flow_table contains mappings of flows to the last CPU
604 * on which they were processed by the application (set in recvmsg). 604 * on which they were processed by the application (set in recvmsg).
605 */ 605 */
606 struct rps_sock_flow_table { 606 struct rps_sock_flow_table {
607 unsigned int mask; 607 unsigned int mask;
608 u16 ents[0]; 608 u16 ents[0];
609 }; 609 };
610 #define RPS_SOCK_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_sock_flow_table) + \ 610 #define RPS_SOCK_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_sock_flow_table) + \
611 (_num * sizeof(u16))) 611 (_num * sizeof(u16)))
612 612
613 #define RPS_NO_CPU 0xffff 613 #define RPS_NO_CPU 0xffff
614 614
615 static inline void rps_record_sock_flow(struct rps_sock_flow_table *table, 615 static inline void rps_record_sock_flow(struct rps_sock_flow_table *table,
616 u32 hash) 616 u32 hash)
617 { 617 {
618 if (table && hash) { 618 if (table && hash) {
619 unsigned int cpu, index = hash & table->mask; 619 unsigned int cpu, index = hash & table->mask;
620 620
621 /* We only give a hint, preemption can change cpu under us */ 621 /* We only give a hint, preemption can change cpu under us */
622 cpu = raw_smp_processor_id(); 622 cpu = raw_smp_processor_id();
623 623
624 if (table->ents[index] != cpu) 624 if (table->ents[index] != cpu)
625 table->ents[index] = cpu; 625 table->ents[index] = cpu;
626 } 626 }
627 } 627 }
628 628
629 static inline void rps_reset_sock_flow(struct rps_sock_flow_table *table, 629 static inline void rps_reset_sock_flow(struct rps_sock_flow_table *table,
630 u32 hash) 630 u32 hash)
631 { 631 {
632 if (table && hash) 632 if (table && hash)
633 table->ents[hash & table->mask] = RPS_NO_CPU; 633 table->ents[hash & table->mask] = RPS_NO_CPU;
634 } 634 }
635 635
636 extern struct rps_sock_flow_table __rcu *rps_sock_flow_table; 636 extern struct rps_sock_flow_table __rcu *rps_sock_flow_table;
637 637
638 #ifdef CONFIG_RFS_ACCEL 638 #ifdef CONFIG_RFS_ACCEL
639 extern bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index, 639 extern bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index,
640 u32 flow_id, u16 filter_id); 640 u32 flow_id, u16 filter_id);
641 #endif 641 #endif
642 642
643 /* This structure contains an instance of an RX queue. */ 643 /* This structure contains an instance of an RX queue. */
644 struct netdev_rx_queue { 644 struct netdev_rx_queue {
645 struct rps_map __rcu *rps_map; 645 struct rps_map __rcu *rps_map;
646 struct rps_dev_flow_table __rcu *rps_flow_table; 646 struct rps_dev_flow_table __rcu *rps_flow_table;
647 struct kobject kobj; 647 struct kobject kobj;
648 struct net_device *dev; 648 struct net_device *dev;
649 } ____cacheline_aligned_in_smp; 649 } ____cacheline_aligned_in_smp;
650 #endif /* CONFIG_RPS */ 650 #endif /* CONFIG_RPS */
651 651
652 #ifdef CONFIG_XPS 652 #ifdef CONFIG_XPS
653 /* 653 /*
654 * This structure holds an XPS map which can be of variable length. The 654 * This structure holds an XPS map which can be of variable length. The
655 * map is an array of queues. 655 * map is an array of queues.
656 */ 656 */
657 struct xps_map { 657 struct xps_map {
658 unsigned int len; 658 unsigned int len;
659 unsigned int alloc_len; 659 unsigned int alloc_len;
660 struct rcu_head rcu; 660 struct rcu_head rcu;
661 u16 queues[0]; 661 u16 queues[0];
662 }; 662 };
663 #define XPS_MAP_SIZE(_num) (sizeof(struct xps_map) + (_num * sizeof(u16))) 663 #define XPS_MAP_SIZE(_num) (sizeof(struct xps_map) + (_num * sizeof(u16)))
664 #define XPS_MIN_MAP_ALLOC ((L1_CACHE_BYTES - sizeof(struct xps_map)) \ 664 #define XPS_MIN_MAP_ALLOC ((L1_CACHE_BYTES - sizeof(struct xps_map)) \
665 / sizeof(u16)) 665 / sizeof(u16))
666 666
667 /* 667 /*
668 * This structure holds all XPS maps for device. Maps are indexed by CPU. 668 * This structure holds all XPS maps for device. Maps are indexed by CPU.
669 */ 669 */
670 struct xps_dev_maps { 670 struct xps_dev_maps {
671 struct rcu_head rcu; 671 struct rcu_head rcu;
672 struct xps_map __rcu *cpu_map[0]; 672 struct xps_map __rcu *cpu_map[0];
673 }; 673 };
674 #define XPS_DEV_MAPS_SIZE (sizeof(struct xps_dev_maps) + \ 674 #define XPS_DEV_MAPS_SIZE (sizeof(struct xps_dev_maps) + \
675 (nr_cpu_ids * sizeof(struct xps_map *))) 675 (nr_cpu_ids * sizeof(struct xps_map *)))
676 #endif /* CONFIG_XPS */ 676 #endif /* CONFIG_XPS */
677 677
678 #define TC_MAX_QUEUE 16 678 #define TC_MAX_QUEUE 16
679 #define TC_BITMASK 15 679 #define TC_BITMASK 15
680 /* HW offloaded queuing disciplines txq count and offset maps */ 680 /* HW offloaded queuing disciplines txq count and offset maps */
681 struct netdev_tc_txq { 681 struct netdev_tc_txq {
682 u16 count; 682 u16 count;
683 u16 offset; 683 u16 offset;
684 }; 684 };
685 685
686 /* 686 /*
687 * This structure defines the management hooks for network devices. 687 * This structure defines the management hooks for network devices.
688 * The following hooks can be defined; unless noted otherwise, they are 688 * The following hooks can be defined; unless noted otherwise, they are
689 * optional and can be filled with a null pointer. 689 * optional and can be filled with a null pointer.
690 * 690 *
691 * int (*ndo_init)(struct net_device *dev); 691 * int (*ndo_init)(struct net_device *dev);
692 * This function is called once when network device is registered. 692 * This function is called once when network device is registered.
693 * The network device can use this to any late stage initializaton 693 * The network device can use this to any late stage initializaton
694 * or semantic validattion. It can fail with an error code which will 694 * or semantic validattion. It can fail with an error code which will
695 * be propogated back to register_netdev 695 * be propogated back to register_netdev
696 * 696 *
697 * void (*ndo_uninit)(struct net_device *dev); 697 * void (*ndo_uninit)(struct net_device *dev);
698 * This function is called when device is unregistered or when registration 698 * This function is called when device is unregistered or when registration
699 * fails. It is not called if init fails. 699 * fails. It is not called if init fails.
700 * 700 *
701 * int (*ndo_open)(struct net_device *dev); 701 * int (*ndo_open)(struct net_device *dev);
702 * This function is called when network device transistions to the up 702 * This function is called when network device transistions to the up
703 * state. 703 * state.
704 * 704 *
705 * int (*ndo_stop)(struct net_device *dev); 705 * int (*ndo_stop)(struct net_device *dev);
706 * This function is called when network device transistions to the down 706 * This function is called when network device transistions to the down
707 * state. 707 * state.
708 * 708 *
709 * netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb, 709 * netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
710 * struct net_device *dev); 710 * struct net_device *dev);
711 * Called when a packet needs to be transmitted. 711 * Called when a packet needs to be transmitted.
712 * Must return NETDEV_TX_OK , NETDEV_TX_BUSY. 712 * Must return NETDEV_TX_OK , NETDEV_TX_BUSY.
713 * (can also return NETDEV_TX_LOCKED iff NETIF_F_LLTX) 713 * (can also return NETDEV_TX_LOCKED iff NETIF_F_LLTX)
714 * Required can not be NULL. 714 * Required can not be NULL.
715 * 715 *
716 * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb); 716 * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb);
717 * Called to decide which queue to when device supports multiple 717 * Called to decide which queue to when device supports multiple
718 * transmit queues. 718 * transmit queues.
719 * 719 *
720 * void (*ndo_change_rx_flags)(struct net_device *dev, int flags); 720 * void (*ndo_change_rx_flags)(struct net_device *dev, int flags);
721 * This function is called to allow device receiver to make 721 * This function is called to allow device receiver to make
722 * changes to configuration when multicast or promiscious is enabled. 722 * changes to configuration when multicast or promiscious is enabled.
723 * 723 *
724 * void (*ndo_set_rx_mode)(struct net_device *dev); 724 * void (*ndo_set_rx_mode)(struct net_device *dev);
725 * This function is called device changes address list filtering. 725 * This function is called device changes address list filtering.
726 * 726 *
727 * void (*ndo_set_multicast_list)(struct net_device *dev); 727 * void (*ndo_set_multicast_list)(struct net_device *dev);
728 * This function is called when the multicast address list changes. 728 * This function is called when the multicast address list changes.
729 * 729 *
730 * int (*ndo_set_mac_address)(struct net_device *dev, void *addr); 730 * int (*ndo_set_mac_address)(struct net_device *dev, void *addr);
731 * This function is called when the Media Access Control address 731 * This function is called when the Media Access Control address
732 * needs to be changed. If this interface is not defined, the 732 * needs to be changed. If this interface is not defined, the
733 * mac address can not be changed. 733 * mac address can not be changed.
734 * 734 *
735 * int (*ndo_validate_addr)(struct net_device *dev); 735 * int (*ndo_validate_addr)(struct net_device *dev);
736 * Test if Media Access Control address is valid for the device. 736 * Test if Media Access Control address is valid for the device.
737 * 737 *
738 * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd); 738 * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);
739 * Called when a user request an ioctl which can't be handled by 739 * Called when a user request an ioctl which can't be handled by
740 * the generic interface code. If not defined ioctl's return 740 * the generic interface code. If not defined ioctl's return
741 * not supported error code. 741 * not supported error code.
742 * 742 *
743 * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map); 743 * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map);
744 * Used to set network devices bus interface parameters. This interface 744 * Used to set network devices bus interface parameters. This interface
745 * is retained for legacy reason, new devices should use the bus 745 * is retained for legacy reason, new devices should use the bus
746 * interface (PCI) for low level management. 746 * interface (PCI) for low level management.
747 * 747 *
748 * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu); 748 * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu);
749 * Called when a user wants to change the Maximum Transfer Unit 749 * Called when a user wants to change the Maximum Transfer Unit
750 * of a device. If not defined, any request to change MTU will 750 * of a device. If not defined, any request to change MTU will
751 * will return an error. 751 * will return an error.
752 * 752 *
753 * void (*ndo_tx_timeout)(struct net_device *dev); 753 * void (*ndo_tx_timeout)(struct net_device *dev);
754 * Callback uses when the transmitter has not made any progress 754 * Callback uses when the transmitter has not made any progress
755 * for dev->watchdog ticks. 755 * for dev->watchdog ticks.
756 * 756 *
757 * struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev, 757 * struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev,
758 * struct rtnl_link_stats64 *storage); 758 * struct rtnl_link_stats64 *storage);
759 * struct net_device_stats* (*ndo_get_stats)(struct net_device *dev); 759 * struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
760 * Called when a user wants to get the network device usage 760 * Called when a user wants to get the network device usage
761 * statistics. Drivers must do one of the following: 761 * statistics. Drivers must do one of the following:
762 * 1. Define @ndo_get_stats64 to fill in a zero-initialised 762 * 1. Define @ndo_get_stats64 to fill in a zero-initialised
763 * rtnl_link_stats64 structure passed by the caller. 763 * rtnl_link_stats64 structure passed by the caller.
764 * 2. Define @ndo_get_stats to update a net_device_stats structure 764 * 2. Define @ndo_get_stats to update a net_device_stats structure
765 * (which should normally be dev->stats) and return a pointer to 765 * (which should normally be dev->stats) and return a pointer to
766 * it. The structure may be changed asynchronously only if each 766 * it. The structure may be changed asynchronously only if each
767 * field is written atomically. 767 * field is written atomically.
768 * 3. Update dev->stats asynchronously and atomically, and define 768 * 3. Update dev->stats asynchronously and atomically, and define
769 * neither operation. 769 * neither operation.
770 * 770 *
771 * void (*ndo_vlan_rx_add_vid)(struct net_device *dev, unsigned short vid); 771 * void (*ndo_vlan_rx_add_vid)(struct net_device *dev, unsigned short vid);
772 * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER) 772 * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
773 * this function is called when a VLAN id is registered. 773 * this function is called when a VLAN id is registered.
774 * 774 *
775 * void (*ndo_vlan_rx_kill_vid)(struct net_device *dev, unsigned short vid); 775 * void (*ndo_vlan_rx_kill_vid)(struct net_device *dev, unsigned short vid);
776 * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER) 776 * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
777 * this function is called when a VLAN id is unregistered. 777 * this function is called when a VLAN id is unregistered.
778 * 778 *
779 * void (*ndo_poll_controller)(struct net_device *dev); 779 * void (*ndo_poll_controller)(struct net_device *dev);
780 * 780 *
781 * SR-IOV management functions. 781 * SR-IOV management functions.
782 * int (*ndo_set_vf_mac)(struct net_device *dev, int vf, u8* mac); 782 * int (*ndo_set_vf_mac)(struct net_device *dev, int vf, u8* mac);
783 * int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan, u8 qos); 783 * int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan, u8 qos);
784 * int (*ndo_set_vf_tx_rate)(struct net_device *dev, int vf, int rate); 784 * int (*ndo_set_vf_tx_rate)(struct net_device *dev, int vf, int rate);
785 * int (*ndo_get_vf_config)(struct net_device *dev, 785 * int (*ndo_get_vf_config)(struct net_device *dev,
786 * int vf, struct ifla_vf_info *ivf); 786 * int vf, struct ifla_vf_info *ivf);
787 * int (*ndo_set_vf_port)(struct net_device *dev, int vf, 787 * int (*ndo_set_vf_port)(struct net_device *dev, int vf,
788 * struct nlattr *port[]); 788 * struct nlattr *port[]);
789 * int (*ndo_get_vf_port)(struct net_device *dev, int vf, struct sk_buff *skb); 789 * int (*ndo_get_vf_port)(struct net_device *dev, int vf, struct sk_buff *skb);
790 * int (*ndo_setup_tc)(struct net_device *dev, u8 tc) 790 * int (*ndo_setup_tc)(struct net_device *dev, u8 tc)
791 * Called to setup 'tc' number of traffic classes in the net device. This 791 * Called to setup 'tc' number of traffic classes in the net device. This
792 * is always called from the stack with the rtnl lock held and netif tx 792 * is always called from the stack with the rtnl lock held and netif tx
793 * queues stopped. This allows the netdevice to perform queue management 793 * queues stopped. This allows the netdevice to perform queue management
794 * safely. 794 * safely.
795 * 795 *
796 * Fiber Channel over Ethernet (FCoE) offload functions. 796 * Fiber Channel over Ethernet (FCoE) offload functions.
797 * int (*ndo_fcoe_enable)(struct net_device *dev); 797 * int (*ndo_fcoe_enable)(struct net_device *dev);
798 * Called when the FCoE protocol stack wants to start using LLD for FCoE 798 * Called when the FCoE protocol stack wants to start using LLD for FCoE
799 * so the underlying device can perform whatever needed configuration or 799 * so the underlying device can perform whatever needed configuration or
800 * initialization to support acceleration of FCoE traffic. 800 * initialization to support acceleration of FCoE traffic.
801 * 801 *
802 * int (*ndo_fcoe_disable)(struct net_device *dev); 802 * int (*ndo_fcoe_disable)(struct net_device *dev);
803 * Called when the FCoE protocol stack wants to stop using LLD for FCoE 803 * Called when the FCoE protocol stack wants to stop using LLD for FCoE
804 * so the underlying device can perform whatever needed clean-ups to 804 * so the underlying device can perform whatever needed clean-ups to
805 * stop supporting acceleration of FCoE traffic. 805 * stop supporting acceleration of FCoE traffic.
806 * 806 *
807 * int (*ndo_fcoe_ddp_setup)(struct net_device *dev, u16 xid, 807 * int (*ndo_fcoe_ddp_setup)(struct net_device *dev, u16 xid,
808 * struct scatterlist *sgl, unsigned int sgc); 808 * struct scatterlist *sgl, unsigned int sgc);
809 * Called when the FCoE Initiator wants to initialize an I/O that 809 * Called when the FCoE Initiator wants to initialize an I/O that
810 * is a possible candidate for Direct Data Placement (DDP). The LLD can 810 * is a possible candidate for Direct Data Placement (DDP). The LLD can
811 * perform necessary setup and returns 1 to indicate the device is set up 811 * perform necessary setup and returns 1 to indicate the device is set up
812 * successfully to perform DDP on this I/O, otherwise this returns 0. 812 * successfully to perform DDP on this I/O, otherwise this returns 0.
813 * 813 *
814 * int (*ndo_fcoe_ddp_done)(struct net_device *dev, u16 xid); 814 * int (*ndo_fcoe_ddp_done)(struct net_device *dev, u16 xid);
815 * Called when the FCoE Initiator/Target is done with the DDPed I/O as 815 * Called when the FCoE Initiator/Target is done with the DDPed I/O as
816 * indicated by the FC exchange id 'xid', so the underlying device can 816 * indicated by the FC exchange id 'xid', so the underlying device can
817 * clean up and reuse resources for later DDP requests. 817 * clean up and reuse resources for later DDP requests.
818 * 818 *
819 * int (*ndo_fcoe_ddp_target)(struct net_device *dev, u16 xid, 819 * int (*ndo_fcoe_ddp_target)(struct net_device *dev, u16 xid,
820 * struct scatterlist *sgl, unsigned int sgc); 820 * struct scatterlist *sgl, unsigned int sgc);
821 * Called when the FCoE Target wants to initialize an I/O that 821 * Called when the FCoE Target wants to initialize an I/O that
822 * is a possible candidate for Direct Data Placement (DDP). The LLD can 822 * is a possible candidate for Direct Data Placement (DDP). The LLD can
823 * perform necessary setup and returns 1 to indicate the device is set up 823 * perform necessary setup and returns 1 to indicate the device is set up
824 * successfully to perform DDP on this I/O, otherwise this returns 0. 824 * successfully to perform DDP on this I/O, otherwise this returns 0.
825 * 825 *
826 * int (*ndo_fcoe_get_wwn)(struct net_device *dev, u64 *wwn, int type); 826 * int (*ndo_fcoe_get_wwn)(struct net_device *dev, u64 *wwn, int type);
827 * Called when the underlying device wants to override default World Wide 827 * Called when the underlying device wants to override default World Wide
828 * Name (WWN) generation mechanism in FCoE protocol stack to pass its own 828 * Name (WWN) generation mechanism in FCoE protocol stack to pass its own
829 * World Wide Port Name (WWPN) or World Wide Node Name (WWNN) to the FCoE 829 * World Wide Port Name (WWPN) or World Wide Node Name (WWNN) to the FCoE
830 * protocol stack to use. 830 * protocol stack to use.
831 * 831 *
832 * RFS acceleration. 832 * RFS acceleration.
833 * int (*ndo_rx_flow_steer)(struct net_device *dev, const struct sk_buff *skb, 833 * int (*ndo_rx_flow_steer)(struct net_device *dev, const struct sk_buff *skb,
834 * u16 rxq_index, u32 flow_id); 834 * u16 rxq_index, u32 flow_id);
835 * Set hardware filter for RFS. rxq_index is the target queue index; 835 * Set hardware filter for RFS. rxq_index is the target queue index;
836 * flow_id is a flow ID to be passed to rps_may_expire_flow() later. 836 * flow_id is a flow ID to be passed to rps_may_expire_flow() later.
837 * Return the filter ID on success, or a negative error code. 837 * Return the filter ID on success, or a negative error code.
838 * 838 *
839 * Slave management functions (for bridge, bonding, etc). User should 839 * Slave management functions (for bridge, bonding, etc). User should
840 * call netdev_set_master() to set dev->master properly. 840 * call netdev_set_master() to set dev->master properly.
841 * int (*ndo_add_slave)(struct net_device *dev, struct net_device *slave_dev); 841 * int (*ndo_add_slave)(struct net_device *dev, struct net_device *slave_dev);
842 * Called to make another netdev an underling. 842 * Called to make another netdev an underling.
843 * 843 *
844 * int (*ndo_del_slave)(struct net_device *dev, struct net_device *slave_dev); 844 * int (*ndo_del_slave)(struct net_device *dev, struct net_device *slave_dev);
845 * Called to release previously enslaved netdev. 845 * Called to release previously enslaved netdev.
846 * 846 *
847 * Feature/offload setting functions. 847 * Feature/offload setting functions.
848 * u32 (*ndo_fix_features)(struct net_device *dev, u32 features); 848 * u32 (*ndo_fix_features)(struct net_device *dev, u32 features);
849 * Adjusts the requested feature flags according to device-specific 849 * Adjusts the requested feature flags according to device-specific
850 * constraints, and returns the resulting flags. Must not modify 850 * constraints, and returns the resulting flags. Must not modify
851 * the device state. 851 * the device state.
852 * 852 *
853 * int (*ndo_set_features)(struct net_device *dev, u32 features); 853 * int (*ndo_set_features)(struct net_device *dev, u32 features);
854 * Called to update device configuration to new features. Passed 854 * Called to update device configuration to new features. Passed
855 * feature set might be less than what was returned by ndo_fix_features()). 855 * feature set might be less than what was returned by ndo_fix_features()).
856 * Must return >0 or -errno if it changed dev->features itself. 856 * Must return >0 or -errno if it changed dev->features itself.
857 * 857 *
858 */ 858 */
859 struct net_device_ops { 859 struct net_device_ops {
860 int (*ndo_init)(struct net_device *dev); 860 int (*ndo_init)(struct net_device *dev);
861 void (*ndo_uninit)(struct net_device *dev); 861 void (*ndo_uninit)(struct net_device *dev);
862 int (*ndo_open)(struct net_device *dev); 862 int (*ndo_open)(struct net_device *dev);
863 int (*ndo_stop)(struct net_device *dev); 863 int (*ndo_stop)(struct net_device *dev);
864 netdev_tx_t (*ndo_start_xmit) (struct sk_buff *skb, 864 netdev_tx_t (*ndo_start_xmit) (struct sk_buff *skb,
865 struct net_device *dev); 865 struct net_device *dev);
866 u16 (*ndo_select_queue)(struct net_device *dev, 866 u16 (*ndo_select_queue)(struct net_device *dev,
867 struct sk_buff *skb); 867 struct sk_buff *skb);
868 void (*ndo_change_rx_flags)(struct net_device *dev, 868 void (*ndo_change_rx_flags)(struct net_device *dev,
869 int flags); 869 int flags);
870 void (*ndo_set_rx_mode)(struct net_device *dev); 870 void (*ndo_set_rx_mode)(struct net_device *dev);
871 void (*ndo_set_multicast_list)(struct net_device *dev); 871 void (*ndo_set_multicast_list)(struct net_device *dev);
872 int (*ndo_set_mac_address)(struct net_device *dev, 872 int (*ndo_set_mac_address)(struct net_device *dev,
873 void *addr); 873 void *addr);
874 int (*ndo_validate_addr)(struct net_device *dev); 874 int (*ndo_validate_addr)(struct net_device *dev);
875 int (*ndo_do_ioctl)(struct net_device *dev, 875 int (*ndo_do_ioctl)(struct net_device *dev,
876 struct ifreq *ifr, int cmd); 876 struct ifreq *ifr, int cmd);
877 int (*ndo_set_config)(struct net_device *dev, 877 int (*ndo_set_config)(struct net_device *dev,
878 struct ifmap *map); 878 struct ifmap *map);
879 int (*ndo_change_mtu)(struct net_device *dev, 879 int (*ndo_change_mtu)(struct net_device *dev,
880 int new_mtu); 880 int new_mtu);
881 int (*ndo_neigh_setup)(struct net_device *dev, 881 int (*ndo_neigh_setup)(struct net_device *dev,
882 struct neigh_parms *); 882 struct neigh_parms *);
883 void (*ndo_tx_timeout) (struct net_device *dev); 883 void (*ndo_tx_timeout) (struct net_device *dev);
884 884
885 struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev, 885 struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev,
886 struct rtnl_link_stats64 *storage); 886 struct rtnl_link_stats64 *storage);
887 struct net_device_stats* (*ndo_get_stats)(struct net_device *dev); 887 struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
888 888
889 void (*ndo_vlan_rx_add_vid)(struct net_device *dev, 889 void (*ndo_vlan_rx_add_vid)(struct net_device *dev,
890 unsigned short vid); 890 unsigned short vid);
891 void (*ndo_vlan_rx_kill_vid)(struct net_device *dev, 891 void (*ndo_vlan_rx_kill_vid)(struct net_device *dev,
892 unsigned short vid); 892 unsigned short vid);
893 #ifdef CONFIG_NET_POLL_CONTROLLER 893 #ifdef CONFIG_NET_POLL_CONTROLLER
894 void (*ndo_poll_controller)(struct net_device *dev); 894 void (*ndo_poll_controller)(struct net_device *dev);
895 int (*ndo_netpoll_setup)(struct net_device *dev, 895 int (*ndo_netpoll_setup)(struct net_device *dev,
896 struct netpoll_info *info); 896 struct netpoll_info *info);
897 void (*ndo_netpoll_cleanup)(struct net_device *dev); 897 void (*ndo_netpoll_cleanup)(struct net_device *dev);
898 #endif 898 #endif
899 int (*ndo_set_vf_mac)(struct net_device *dev, 899 int (*ndo_set_vf_mac)(struct net_device *dev,
900 int queue, u8 *mac); 900 int queue, u8 *mac);
901 int (*ndo_set_vf_vlan)(struct net_device *dev, 901 int (*ndo_set_vf_vlan)(struct net_device *dev,
902 int queue, u16 vlan, u8 qos); 902 int queue, u16 vlan, u8 qos);
903 int (*ndo_set_vf_tx_rate)(struct net_device *dev, 903 int (*ndo_set_vf_tx_rate)(struct net_device *dev,
904 int vf, int rate); 904 int vf, int rate);
905 int (*ndo_get_vf_config)(struct net_device *dev, 905 int (*ndo_get_vf_config)(struct net_device *dev,
906 int vf, 906 int vf,
907 struct ifla_vf_info *ivf); 907 struct ifla_vf_info *ivf);
908 int (*ndo_set_vf_port)(struct net_device *dev, 908 int (*ndo_set_vf_port)(struct net_device *dev,
909 int vf, 909 int vf,
910 struct nlattr *port[]); 910 struct nlattr *port[]);
911 int (*ndo_get_vf_port)(struct net_device *dev, 911 int (*ndo_get_vf_port)(struct net_device *dev,
912 int vf, struct sk_buff *skb); 912 int vf, struct sk_buff *skb);
913 int (*ndo_setup_tc)(struct net_device *dev, u8 tc); 913 int (*ndo_setup_tc)(struct net_device *dev, u8 tc);
914 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE) 914 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
915 int (*ndo_fcoe_enable)(struct net_device *dev); 915 int (*ndo_fcoe_enable)(struct net_device *dev);
916 int (*ndo_fcoe_disable)(struct net_device *dev); 916 int (*ndo_fcoe_disable)(struct net_device *dev);
917 int (*ndo_fcoe_ddp_setup)(struct net_device *dev, 917 int (*ndo_fcoe_ddp_setup)(struct net_device *dev,
918 u16 xid, 918 u16 xid,
919 struct scatterlist *sgl, 919 struct scatterlist *sgl,
920 unsigned int sgc); 920 unsigned int sgc);
921 int (*ndo_fcoe_ddp_done)(struct net_device *dev, 921 int (*ndo_fcoe_ddp_done)(struct net_device *dev,
922 u16 xid); 922 u16 xid);
923 int (*ndo_fcoe_ddp_target)(struct net_device *dev, 923 int (*ndo_fcoe_ddp_target)(struct net_device *dev,
924 u16 xid, 924 u16 xid,
925 struct scatterlist *sgl, 925 struct scatterlist *sgl,
926 unsigned int sgc); 926 unsigned int sgc);
927 #define NETDEV_FCOE_WWNN 0 927 #define NETDEV_FCOE_WWNN 0
928 #define NETDEV_FCOE_WWPN 1 928 #define NETDEV_FCOE_WWPN 1
929 int (*ndo_fcoe_get_wwn)(struct net_device *dev, 929 int (*ndo_fcoe_get_wwn)(struct net_device *dev,
930 u64 *wwn, int type); 930 u64 *wwn, int type);
931 #endif 931 #endif
932 #ifdef CONFIG_RFS_ACCEL 932 #ifdef CONFIG_RFS_ACCEL
933 int (*ndo_rx_flow_steer)(struct net_device *dev, 933 int (*ndo_rx_flow_steer)(struct net_device *dev,
934 const struct sk_buff *skb, 934 const struct sk_buff *skb,
935 u16 rxq_index, 935 u16 rxq_index,
936 u32 flow_id); 936 u32 flow_id);
937 #endif 937 #endif
938 int (*ndo_add_slave)(struct net_device *dev, 938 int (*ndo_add_slave)(struct net_device *dev,
939 struct net_device *slave_dev); 939 struct net_device *slave_dev);
940 int (*ndo_del_slave)(struct net_device *dev, 940 int (*ndo_del_slave)(struct net_device *dev,
941 struct net_device *slave_dev); 941 struct net_device *slave_dev);
942 u32 (*ndo_fix_features)(struct net_device *dev, 942 u32 (*ndo_fix_features)(struct net_device *dev,
943 u32 features); 943 u32 features);
944 int (*ndo_set_features)(struct net_device *dev, 944 int (*ndo_set_features)(struct net_device *dev,
945 u32 features); 945 u32 features);
946 }; 946 };
947 947
948 /* 948 /*
949 * The DEVICE structure. 949 * The DEVICE structure.
950 * Actually, this whole structure is a big mistake. It mixes I/O 950 * Actually, this whole structure is a big mistake. It mixes I/O
951 * data with strictly "high-level" data, and it has to know about 951 * data with strictly "high-level" data, and it has to know about
952 * almost every data structure used in the INET module. 952 * almost every data structure used in the INET module.
953 * 953 *
954 * FIXME: cleanup struct net_device such that network protocol info 954 * FIXME: cleanup struct net_device such that network protocol info
955 * moves out. 955 * moves out.
956 */ 956 */
957 957
958 struct net_device { 958 struct net_device {
959 959
960 /* 960 /*
961 * This is the first field of the "visible" part of this structure 961 * This is the first field of the "visible" part of this structure
962 * (i.e. as seen by users in the "Space.c" file). It is the name 962 * (i.e. as seen by users in the "Space.c" file). It is the name
963 * of the interface. 963 * of the interface.
964 */ 964 */
965 char name[IFNAMSIZ]; 965 char name[IFNAMSIZ];
966 966
967 struct pm_qos_request_list pm_qos_req; 967 struct pm_qos_request pm_qos_req;
968 968
969 /* device name hash chain */ 969 /* device name hash chain */
970 struct hlist_node name_hlist; 970 struct hlist_node name_hlist;
971 /* snmp alias */ 971 /* snmp alias */
972 char *ifalias; 972 char *ifalias;
973 973
974 /* 974 /*
975 * I/O specific fields 975 * I/O specific fields
976 * FIXME: Merge these and struct ifmap into one 976 * FIXME: Merge these and struct ifmap into one
977 */ 977 */
978 unsigned long mem_end; /* shared mem end */ 978 unsigned long mem_end; /* shared mem end */
979 unsigned long mem_start; /* shared mem start */ 979 unsigned long mem_start; /* shared mem start */
980 unsigned long base_addr; /* device I/O address */ 980 unsigned long base_addr; /* device I/O address */
981 unsigned int irq; /* device IRQ number */ 981 unsigned int irq; /* device IRQ number */
982 982
983 /* 983 /*
984 * Some hardware also needs these fields, but they are not 984 * Some hardware also needs these fields, but they are not
985 * part of the usual set specified in Space.c. 985 * part of the usual set specified in Space.c.
986 */ 986 */
987 987
988 unsigned long state; 988 unsigned long state;
989 989
990 struct list_head dev_list; 990 struct list_head dev_list;
991 struct list_head napi_list; 991 struct list_head napi_list;
992 struct list_head unreg_list; 992 struct list_head unreg_list;
993 993
994 /* currently active device features */ 994 /* currently active device features */
995 u32 features; 995 u32 features;
996 /* user-changeable features */ 996 /* user-changeable features */
997 u32 hw_features; 997 u32 hw_features;
998 /* user-requested features */ 998 /* user-requested features */
999 u32 wanted_features; 999 u32 wanted_features;
1000 /* mask of features inheritable by VLAN devices */ 1000 /* mask of features inheritable by VLAN devices */
1001 u32 vlan_features; 1001 u32 vlan_features;
1002 1002
1003 /* Net device feature bits; if you change something, 1003 /* Net device feature bits; if you change something,
1004 * also update netdev_features_strings[] in ethtool.c */ 1004 * also update netdev_features_strings[] in ethtool.c */
1005 1005
1006 #define NETIF_F_SG 1 /* Scatter/gather IO. */ 1006 #define NETIF_F_SG 1 /* Scatter/gather IO. */
1007 #define NETIF_F_IP_CSUM 2 /* Can checksum TCP/UDP over IPv4. */ 1007 #define NETIF_F_IP_CSUM 2 /* Can checksum TCP/UDP over IPv4. */
1008 #define NETIF_F_NO_CSUM 4 /* Does not require checksum. F.e. loopack. */ 1008 #define NETIF_F_NO_CSUM 4 /* Does not require checksum. F.e. loopack. */
1009 #define NETIF_F_HW_CSUM 8 /* Can checksum all the packets. */ 1009 #define NETIF_F_HW_CSUM 8 /* Can checksum all the packets. */
1010 #define NETIF_F_IPV6_CSUM 16 /* Can checksum TCP/UDP over IPV6 */ 1010 #define NETIF_F_IPV6_CSUM 16 /* Can checksum TCP/UDP over IPV6 */
1011 #define NETIF_F_HIGHDMA 32 /* Can DMA to high memory. */ 1011 #define NETIF_F_HIGHDMA 32 /* Can DMA to high memory. */
1012 #define NETIF_F_FRAGLIST 64 /* Scatter/gather IO. */ 1012 #define NETIF_F_FRAGLIST 64 /* Scatter/gather IO. */
1013 #define NETIF_F_HW_VLAN_TX 128 /* Transmit VLAN hw acceleration */ 1013 #define NETIF_F_HW_VLAN_TX 128 /* Transmit VLAN hw acceleration */
1014 #define NETIF_F_HW_VLAN_RX 256 /* Receive VLAN hw acceleration */ 1014 #define NETIF_F_HW_VLAN_RX 256 /* Receive VLAN hw acceleration */
1015 #define NETIF_F_HW_VLAN_FILTER 512 /* Receive filtering on VLAN */ 1015 #define NETIF_F_HW_VLAN_FILTER 512 /* Receive filtering on VLAN */
1016 #define NETIF_F_VLAN_CHALLENGED 1024 /* Device cannot handle VLAN packets */ 1016 #define NETIF_F_VLAN_CHALLENGED 1024 /* Device cannot handle VLAN packets */
1017 #define NETIF_F_GSO 2048 /* Enable software GSO. */ 1017 #define NETIF_F_GSO 2048 /* Enable software GSO. */
1018 #define NETIF_F_LLTX 4096 /* LockLess TX - deprecated. Please */ 1018 #define NETIF_F_LLTX 4096 /* LockLess TX - deprecated. Please */
1019 /* do not use LLTX in new drivers */ 1019 /* do not use LLTX in new drivers */
1020 #define NETIF_F_NETNS_LOCAL 8192 /* Does not change network namespaces */ 1020 #define NETIF_F_NETNS_LOCAL 8192 /* Does not change network namespaces */
1021 #define NETIF_F_GRO 16384 /* Generic receive offload */ 1021 #define NETIF_F_GRO 16384 /* Generic receive offload */
1022 #define NETIF_F_LRO 32768 /* large receive offload */ 1022 #define NETIF_F_LRO 32768 /* large receive offload */
1023 1023
1024 /* the GSO_MASK reserves bits 16 through 23 */ 1024 /* the GSO_MASK reserves bits 16 through 23 */
1025 #define NETIF_F_FCOE_CRC (1 << 24) /* FCoE CRC32 */ 1025 #define NETIF_F_FCOE_CRC (1 << 24) /* FCoE CRC32 */
1026 #define NETIF_F_SCTP_CSUM (1 << 25) /* SCTP checksum offload */ 1026 #define NETIF_F_SCTP_CSUM (1 << 25) /* SCTP checksum offload */
1027 #define NETIF_F_FCOE_MTU (1 << 26) /* Supports max FCoE MTU, 2158 bytes*/ 1027 #define NETIF_F_FCOE_MTU (1 << 26) /* Supports max FCoE MTU, 2158 bytes*/
1028 #define NETIF_F_NTUPLE (1 << 27) /* N-tuple filters supported */ 1028 #define NETIF_F_NTUPLE (1 << 27) /* N-tuple filters supported */
1029 #define NETIF_F_RXHASH (1 << 28) /* Receive hashing offload */ 1029 #define NETIF_F_RXHASH (1 << 28) /* Receive hashing offload */
1030 #define NETIF_F_RXCSUM (1 << 29) /* Receive checksumming offload */ 1030 #define NETIF_F_RXCSUM (1 << 29) /* Receive checksumming offload */
1031 #define NETIF_F_NOCACHE_COPY (1 << 30) /* Use no-cache copyfromuser */ 1031 #define NETIF_F_NOCACHE_COPY (1 << 30) /* Use no-cache copyfromuser */
1032 #define NETIF_F_LOOPBACK (1 << 31) /* Enable loopback */ 1032 #define NETIF_F_LOOPBACK (1 << 31) /* Enable loopback */
1033 1033
1034 /* Segmentation offload features */ 1034 /* Segmentation offload features */
1035 #define NETIF_F_GSO_SHIFT 16 1035 #define NETIF_F_GSO_SHIFT 16
1036 #define NETIF_F_GSO_MASK 0x00ff0000 1036 #define NETIF_F_GSO_MASK 0x00ff0000
1037 #define NETIF_F_TSO (SKB_GSO_TCPV4 << NETIF_F_GSO_SHIFT) 1037 #define NETIF_F_TSO (SKB_GSO_TCPV4 << NETIF_F_GSO_SHIFT)
1038 #define NETIF_F_UFO (SKB_GSO_UDP << NETIF_F_GSO_SHIFT) 1038 #define NETIF_F_UFO (SKB_GSO_UDP << NETIF_F_GSO_SHIFT)
1039 #define NETIF_F_GSO_ROBUST (SKB_GSO_DODGY << NETIF_F_GSO_SHIFT) 1039 #define NETIF_F_GSO_ROBUST (SKB_GSO_DODGY << NETIF_F_GSO_SHIFT)
1040 #define NETIF_F_TSO_ECN (SKB_GSO_TCP_ECN << NETIF_F_GSO_SHIFT) 1040 #define NETIF_F_TSO_ECN (SKB_GSO_TCP_ECN << NETIF_F_GSO_SHIFT)
1041 #define NETIF_F_TSO6 (SKB_GSO_TCPV6 << NETIF_F_GSO_SHIFT) 1041 #define NETIF_F_TSO6 (SKB_GSO_TCPV6 << NETIF_F_GSO_SHIFT)
1042 #define NETIF_F_FSO (SKB_GSO_FCOE << NETIF_F_GSO_SHIFT) 1042 #define NETIF_F_FSO (SKB_GSO_FCOE << NETIF_F_GSO_SHIFT)
1043 1043
1044 /* Features valid for ethtool to change */ 1044 /* Features valid for ethtool to change */
1045 /* = all defined minus driver/device-class-related */ 1045 /* = all defined minus driver/device-class-related */
1046 #define NETIF_F_NEVER_CHANGE (NETIF_F_VLAN_CHALLENGED | \ 1046 #define NETIF_F_NEVER_CHANGE (NETIF_F_VLAN_CHALLENGED | \
1047 NETIF_F_LLTX | NETIF_F_NETNS_LOCAL) 1047 NETIF_F_LLTX | NETIF_F_NETNS_LOCAL)
1048 #define NETIF_F_ETHTOOL_BITS (0xff3fffff & ~NETIF_F_NEVER_CHANGE) 1048 #define NETIF_F_ETHTOOL_BITS (0xff3fffff & ~NETIF_F_NEVER_CHANGE)
1049 1049
1050 /* List of features with software fallbacks. */ 1050 /* List of features with software fallbacks. */
1051 #define NETIF_F_GSO_SOFTWARE (NETIF_F_TSO | NETIF_F_TSO_ECN | \ 1051 #define NETIF_F_GSO_SOFTWARE (NETIF_F_TSO | NETIF_F_TSO_ECN | \
1052 NETIF_F_TSO6 | NETIF_F_UFO) 1052 NETIF_F_TSO6 | NETIF_F_UFO)
1053 1053
1054 1054
1055 #define NETIF_F_GEN_CSUM (NETIF_F_NO_CSUM | NETIF_F_HW_CSUM) 1055 #define NETIF_F_GEN_CSUM (NETIF_F_NO_CSUM | NETIF_F_HW_CSUM)
1056 #define NETIF_F_V4_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IP_CSUM) 1056 #define NETIF_F_V4_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IP_CSUM)
1057 #define NETIF_F_V6_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IPV6_CSUM) 1057 #define NETIF_F_V6_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IPV6_CSUM)
1058 #define NETIF_F_ALL_CSUM (NETIF_F_V4_CSUM | NETIF_F_V6_CSUM) 1058 #define NETIF_F_ALL_CSUM (NETIF_F_V4_CSUM | NETIF_F_V6_CSUM)
1059 1059
1060 #define NETIF_F_ALL_TSO (NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN) 1060 #define NETIF_F_ALL_TSO (NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN)
1061 1061
1062 #define NETIF_F_ALL_FCOE (NETIF_F_FCOE_CRC | NETIF_F_FCOE_MTU | \ 1062 #define NETIF_F_ALL_FCOE (NETIF_F_FCOE_CRC | NETIF_F_FCOE_MTU | \
1063 NETIF_F_FSO) 1063 NETIF_F_FSO)
1064 1064
1065 /* 1065 /*
1066 * If one device supports one of these features, then enable them 1066 * If one device supports one of these features, then enable them
1067 * for all in netdev_increment_features. 1067 * for all in netdev_increment_features.
1068 */ 1068 */
1069 #define NETIF_F_ONE_FOR_ALL (NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ROBUST | \ 1069 #define NETIF_F_ONE_FOR_ALL (NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ROBUST | \
1070 NETIF_F_SG | NETIF_F_HIGHDMA | \ 1070 NETIF_F_SG | NETIF_F_HIGHDMA | \
1071 NETIF_F_FRAGLIST | NETIF_F_VLAN_CHALLENGED) 1071 NETIF_F_FRAGLIST | NETIF_F_VLAN_CHALLENGED)
1072 /* 1072 /*
1073 * If one device doesn't support one of these features, then disable it 1073 * If one device doesn't support one of these features, then disable it
1074 * for all in netdev_increment_features. 1074 * for all in netdev_increment_features.
1075 */ 1075 */
1076 #define NETIF_F_ALL_FOR_ALL (NETIF_F_NOCACHE_COPY | NETIF_F_FSO) 1076 #define NETIF_F_ALL_FOR_ALL (NETIF_F_NOCACHE_COPY | NETIF_F_FSO)
1077 1077
1078 /* changeable features with no special hardware requirements */ 1078 /* changeable features with no special hardware requirements */
1079 #define NETIF_F_SOFT_FEATURES (NETIF_F_GSO | NETIF_F_GRO) 1079 #define NETIF_F_SOFT_FEATURES (NETIF_F_GSO | NETIF_F_GRO)
1080 1080
1081 /* Interface index. Unique device identifier */ 1081 /* Interface index. Unique device identifier */
1082 int ifindex; 1082 int ifindex;
1083 int iflink; 1083 int iflink;
1084 1084
1085 struct net_device_stats stats; 1085 struct net_device_stats stats;
1086 atomic_long_t rx_dropped; /* dropped packets by core network 1086 atomic_long_t rx_dropped; /* dropped packets by core network
1087 * Do not use this in drivers. 1087 * Do not use this in drivers.
1088 */ 1088 */
1089 1089
1090 #ifdef CONFIG_WIRELESS_EXT 1090 #ifdef CONFIG_WIRELESS_EXT
1091 /* List of functions to handle Wireless Extensions (instead of ioctl). 1091 /* List of functions to handle Wireless Extensions (instead of ioctl).
1092 * See <net/iw_handler.h> for details. Jean II */ 1092 * See <net/iw_handler.h> for details. Jean II */
1093 const struct iw_handler_def * wireless_handlers; 1093 const struct iw_handler_def * wireless_handlers;
1094 /* Instance data managed by the core of Wireless Extensions. */ 1094 /* Instance data managed by the core of Wireless Extensions. */
1095 struct iw_public_data * wireless_data; 1095 struct iw_public_data * wireless_data;
1096 #endif 1096 #endif
1097 /* Management operations */ 1097 /* Management operations */
1098 const struct net_device_ops *netdev_ops; 1098 const struct net_device_ops *netdev_ops;
1099 const struct ethtool_ops *ethtool_ops; 1099 const struct ethtool_ops *ethtool_ops;
1100 1100
1101 /* Hardware header description */ 1101 /* Hardware header description */
1102 const struct header_ops *header_ops; 1102 const struct header_ops *header_ops;
1103 1103
1104 unsigned int flags; /* interface flags (a la BSD) */ 1104 unsigned int flags; /* interface flags (a la BSD) */
1105 unsigned int priv_flags; /* Like 'flags' but invisible to userspace. */ 1105 unsigned int priv_flags; /* Like 'flags' but invisible to userspace. */
1106 unsigned short gflags; 1106 unsigned short gflags;
1107 unsigned short padded; /* How much padding added by alloc_netdev() */ 1107 unsigned short padded; /* How much padding added by alloc_netdev() */
1108 1108
1109 unsigned char operstate; /* RFC2863 operstate */ 1109 unsigned char operstate; /* RFC2863 operstate */
1110 unsigned char link_mode; /* mapping policy to operstate */ 1110 unsigned char link_mode; /* mapping policy to operstate */
1111 1111
1112 unsigned char if_port; /* Selectable AUI, TP,..*/ 1112 unsigned char if_port; /* Selectable AUI, TP,..*/
1113 unsigned char dma; /* DMA channel */ 1113 unsigned char dma; /* DMA channel */
1114 1114
1115 unsigned int mtu; /* interface MTU value */ 1115 unsigned int mtu; /* interface MTU value */
1116 unsigned short type; /* interface hardware type */ 1116 unsigned short type; /* interface hardware type */
1117 unsigned short hard_header_len; /* hardware hdr length */ 1117 unsigned short hard_header_len; /* hardware hdr length */
1118 1118
1119 /* extra head- and tailroom the hardware may need, but not in all cases 1119 /* extra head- and tailroom the hardware may need, but not in all cases
1120 * can this be guaranteed, especially tailroom. Some cases also use 1120 * can this be guaranteed, especially tailroom. Some cases also use
1121 * LL_MAX_HEADER instead to allocate the skb. 1121 * LL_MAX_HEADER instead to allocate the skb.
1122 */ 1122 */
1123 unsigned short needed_headroom; 1123 unsigned short needed_headroom;
1124 unsigned short needed_tailroom; 1124 unsigned short needed_tailroom;
1125 1125
1126 /* Interface address info. */ 1126 /* Interface address info. */
1127 unsigned char perm_addr[MAX_ADDR_LEN]; /* permanent hw address */ 1127 unsigned char perm_addr[MAX_ADDR_LEN]; /* permanent hw address */
1128 unsigned char addr_assign_type; /* hw address assignment type */ 1128 unsigned char addr_assign_type; /* hw address assignment type */
1129 unsigned char addr_len; /* hardware address length */ 1129 unsigned char addr_len; /* hardware address length */
1130 unsigned short dev_id; /* for shared network cards */ 1130 unsigned short dev_id; /* for shared network cards */
1131 1131
1132 spinlock_t addr_list_lock; 1132 spinlock_t addr_list_lock;
1133 struct netdev_hw_addr_list uc; /* Unicast mac addresses */ 1133 struct netdev_hw_addr_list uc; /* Unicast mac addresses */
1134 struct netdev_hw_addr_list mc; /* Multicast mac addresses */ 1134 struct netdev_hw_addr_list mc; /* Multicast mac addresses */
1135 bool uc_promisc; 1135 bool uc_promisc;
1136 unsigned int promiscuity; 1136 unsigned int promiscuity;
1137 unsigned int allmulti; 1137 unsigned int allmulti;
1138 1138
1139 1139
1140 /* Protocol specific pointers */ 1140 /* Protocol specific pointers */
1141 1141
1142 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE) 1142 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
1143 struct vlan_group __rcu *vlgrp; /* VLAN group */ 1143 struct vlan_group __rcu *vlgrp; /* VLAN group */
1144 #endif 1144 #endif
1145 #ifdef CONFIG_NET_DSA 1145 #ifdef CONFIG_NET_DSA
1146 void *dsa_ptr; /* dsa specific data */ 1146 void *dsa_ptr; /* dsa specific data */
1147 #endif 1147 #endif
1148 void *atalk_ptr; /* AppleTalk link */ 1148 void *atalk_ptr; /* AppleTalk link */
1149 struct in_device __rcu *ip_ptr; /* IPv4 specific data */ 1149 struct in_device __rcu *ip_ptr; /* IPv4 specific data */
1150 struct dn_dev __rcu *dn_ptr; /* DECnet specific data */ 1150 struct dn_dev __rcu *dn_ptr; /* DECnet specific data */
1151 struct inet6_dev __rcu *ip6_ptr; /* IPv6 specific data */ 1151 struct inet6_dev __rcu *ip6_ptr; /* IPv6 specific data */
1152 void *ec_ptr; /* Econet specific data */ 1152 void *ec_ptr; /* Econet specific data */
1153 void *ax25_ptr; /* AX.25 specific data */ 1153 void *ax25_ptr; /* AX.25 specific data */
1154 struct wireless_dev *ieee80211_ptr; /* IEEE 802.11 specific data, 1154 struct wireless_dev *ieee80211_ptr; /* IEEE 802.11 specific data,
1155 assign before registering */ 1155 assign before registering */
1156 1156
1157 /* 1157 /*
1158 * Cache lines mostly used on receive path (including eth_type_trans()) 1158 * Cache lines mostly used on receive path (including eth_type_trans())
1159 */ 1159 */
1160 unsigned long last_rx; /* Time of last Rx 1160 unsigned long last_rx; /* Time of last Rx
1161 * This should not be set in 1161 * This should not be set in
1162 * drivers, unless really needed, 1162 * drivers, unless really needed,
1163 * because network stack (bonding) 1163 * because network stack (bonding)
1164 * use it if/when necessary, to 1164 * use it if/when necessary, to
1165 * avoid dirtying this cache line. 1165 * avoid dirtying this cache line.
1166 */ 1166 */
1167 1167
1168 struct net_device *master; /* Pointer to master device of a group, 1168 struct net_device *master; /* Pointer to master device of a group,
1169 * which this device is member of. 1169 * which this device is member of.
1170 */ 1170 */
1171 1171
1172 /* Interface address info used in eth_type_trans() */ 1172 /* Interface address info used in eth_type_trans() */
1173 unsigned char *dev_addr; /* hw address, (before bcast 1173 unsigned char *dev_addr; /* hw address, (before bcast
1174 because most packets are 1174 because most packets are
1175 unicast) */ 1175 unicast) */
1176 1176
1177 struct netdev_hw_addr_list dev_addrs; /* list of device 1177 struct netdev_hw_addr_list dev_addrs; /* list of device
1178 hw addresses */ 1178 hw addresses */
1179 1179
1180 unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */ 1180 unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */
1181 1181
1182 #if defined(CONFIG_RPS) || defined(CONFIG_XPS) 1182 #if defined(CONFIG_RPS) || defined(CONFIG_XPS)
1183 struct kset *queues_kset; 1183 struct kset *queues_kset;
1184 1184
1185 struct netdev_rx_queue *_rx; 1185 struct netdev_rx_queue *_rx;
1186 1186
1187 /* Number of RX queues allocated at register_netdev() time */ 1187 /* Number of RX queues allocated at register_netdev() time */
1188 unsigned int num_rx_queues; 1188 unsigned int num_rx_queues;
1189 1189
1190 /* Number of RX queues currently active in device */ 1190 /* Number of RX queues currently active in device */
1191 unsigned int real_num_rx_queues; 1191 unsigned int real_num_rx_queues;
1192 1192
1193 #ifdef CONFIG_RFS_ACCEL 1193 #ifdef CONFIG_RFS_ACCEL
1194 /* CPU reverse-mapping for RX completion interrupts, indexed 1194 /* CPU reverse-mapping for RX completion interrupts, indexed
1195 * by RX queue number. Assigned by driver. This must only be 1195 * by RX queue number. Assigned by driver. This must only be
1196 * set if the ndo_rx_flow_steer operation is defined. */ 1196 * set if the ndo_rx_flow_steer operation is defined. */
1197 struct cpu_rmap *rx_cpu_rmap; 1197 struct cpu_rmap *rx_cpu_rmap;
1198 #endif 1198 #endif
1199 #endif 1199 #endif
1200 1200
1201 rx_handler_func_t __rcu *rx_handler; 1201 rx_handler_func_t __rcu *rx_handler;
1202 void __rcu *rx_handler_data; 1202 void __rcu *rx_handler_data;
1203 1203
1204 struct netdev_queue __rcu *ingress_queue; 1204 struct netdev_queue __rcu *ingress_queue;
1205 1205
1206 /* 1206 /*
1207 * Cache lines mostly used on transmit path 1207 * Cache lines mostly used on transmit path
1208 */ 1208 */
1209 struct netdev_queue *_tx ____cacheline_aligned_in_smp; 1209 struct netdev_queue *_tx ____cacheline_aligned_in_smp;
1210 1210
1211 /* Number of TX queues allocated at alloc_netdev_mq() time */ 1211 /* Number of TX queues allocated at alloc_netdev_mq() time */
1212 unsigned int num_tx_queues; 1212 unsigned int num_tx_queues;
1213 1213
1214 /* Number of TX queues currently active in device */ 1214 /* Number of TX queues currently active in device */
1215 unsigned int real_num_tx_queues; 1215 unsigned int real_num_tx_queues;
1216 1216
1217 /* root qdisc from userspace point of view */ 1217 /* root qdisc from userspace point of view */
1218 struct Qdisc *qdisc; 1218 struct Qdisc *qdisc;
1219 1219
1220 unsigned long tx_queue_len; /* Max frames per queue allowed */ 1220 unsigned long tx_queue_len; /* Max frames per queue allowed */
1221 spinlock_t tx_global_lock; 1221 spinlock_t tx_global_lock;
1222 1222
1223 #ifdef CONFIG_XPS 1223 #ifdef CONFIG_XPS
1224 struct xps_dev_maps __rcu *xps_maps; 1224 struct xps_dev_maps __rcu *xps_maps;
1225 #endif 1225 #endif
1226 1226
1227 /* These may be needed for future network-power-down code. */ 1227 /* These may be needed for future network-power-down code. */
1228 1228
1229 /* 1229 /*
1230 * trans_start here is expensive for high speed devices on SMP, 1230 * trans_start here is expensive for high speed devices on SMP,
1231 * please use netdev_queue->trans_start instead. 1231 * please use netdev_queue->trans_start instead.
1232 */ 1232 */
1233 unsigned long trans_start; /* Time (in jiffies) of last Tx */ 1233 unsigned long trans_start; /* Time (in jiffies) of last Tx */
1234 1234
1235 int watchdog_timeo; /* used by dev_watchdog() */ 1235 int watchdog_timeo; /* used by dev_watchdog() */
1236 struct timer_list watchdog_timer; 1236 struct timer_list watchdog_timer;
1237 1237
1238 /* Number of references to this device */ 1238 /* Number of references to this device */
1239 int __percpu *pcpu_refcnt; 1239 int __percpu *pcpu_refcnt;
1240 1240
1241 /* delayed register/unregister */ 1241 /* delayed register/unregister */
1242 struct list_head todo_list; 1242 struct list_head todo_list;
1243 /* device index hash chain */ 1243 /* device index hash chain */
1244 struct hlist_node index_hlist; 1244 struct hlist_node index_hlist;
1245 1245
1246 struct list_head link_watch_list; 1246 struct list_head link_watch_list;
1247 1247
1248 /* register/unregister state machine */ 1248 /* register/unregister state machine */
1249 enum { NETREG_UNINITIALIZED=0, 1249 enum { NETREG_UNINITIALIZED=0,
1250 NETREG_REGISTERED, /* completed register_netdevice */ 1250 NETREG_REGISTERED, /* completed register_netdevice */
1251 NETREG_UNREGISTERING, /* called unregister_netdevice */ 1251 NETREG_UNREGISTERING, /* called unregister_netdevice */
1252 NETREG_UNREGISTERED, /* completed unregister todo */ 1252 NETREG_UNREGISTERED, /* completed unregister todo */
1253 NETREG_RELEASED, /* called free_netdev */ 1253 NETREG_RELEASED, /* called free_netdev */
1254 NETREG_DUMMY, /* dummy device for NAPI poll */ 1254 NETREG_DUMMY, /* dummy device for NAPI poll */
1255 } reg_state:8; 1255 } reg_state:8;
1256 1256
1257 bool dismantle; /* device is going do be freed */ 1257 bool dismantle; /* device is going do be freed */
1258 1258
1259 enum { 1259 enum {
1260 RTNL_LINK_INITIALIZED, 1260 RTNL_LINK_INITIALIZED,
1261 RTNL_LINK_INITIALIZING, 1261 RTNL_LINK_INITIALIZING,
1262 } rtnl_link_state:16; 1262 } rtnl_link_state:16;
1263 1263
1264 /* Called from unregister, can be used to call free_netdev */ 1264 /* Called from unregister, can be used to call free_netdev */
1265 void (*destructor)(struct net_device *dev); 1265 void (*destructor)(struct net_device *dev);
1266 1266
1267 #ifdef CONFIG_NETPOLL 1267 #ifdef CONFIG_NETPOLL
1268 struct netpoll_info *npinfo; 1268 struct netpoll_info *npinfo;
1269 #endif 1269 #endif
1270 1270
1271 #ifdef CONFIG_NET_NS 1271 #ifdef CONFIG_NET_NS
1272 /* Network namespace this network device is inside */ 1272 /* Network namespace this network device is inside */
1273 struct net *nd_net; 1273 struct net *nd_net;
1274 #endif 1274 #endif
1275 1275
1276 /* mid-layer private */ 1276 /* mid-layer private */
1277 union { 1277 union {
1278 void *ml_priv; 1278 void *ml_priv;
1279 struct pcpu_lstats __percpu *lstats; /* loopback stats */ 1279 struct pcpu_lstats __percpu *lstats; /* loopback stats */
1280 struct pcpu_tstats __percpu *tstats; /* tunnel stats */ 1280 struct pcpu_tstats __percpu *tstats; /* tunnel stats */
1281 struct pcpu_dstats __percpu *dstats; /* dummy stats */ 1281 struct pcpu_dstats __percpu *dstats; /* dummy stats */
1282 }; 1282 };
1283 /* GARP */ 1283 /* GARP */
1284 struct garp_port __rcu *garp_port; 1284 struct garp_port __rcu *garp_port;
1285 1285
1286 /* class/net/name entry */ 1286 /* class/net/name entry */
1287 struct device dev; 1287 struct device dev;
1288 /* space for optional device, statistics, and wireless sysfs groups */ 1288 /* space for optional device, statistics, and wireless sysfs groups */
1289 const struct attribute_group *sysfs_groups[4]; 1289 const struct attribute_group *sysfs_groups[4];
1290 1290
1291 /* rtnetlink link ops */ 1291 /* rtnetlink link ops */
1292 const struct rtnl_link_ops *rtnl_link_ops; 1292 const struct rtnl_link_ops *rtnl_link_ops;
1293 1293
1294 /* for setting kernel sock attribute on TCP connection setup */ 1294 /* for setting kernel sock attribute on TCP connection setup */
1295 #define GSO_MAX_SIZE 65536 1295 #define GSO_MAX_SIZE 65536
1296 unsigned int gso_max_size; 1296 unsigned int gso_max_size;
1297 1297
1298 #ifdef CONFIG_DCB 1298 #ifdef CONFIG_DCB
1299 /* Data Center Bridging netlink ops */ 1299 /* Data Center Bridging netlink ops */
1300 const struct dcbnl_rtnl_ops *dcbnl_ops; 1300 const struct dcbnl_rtnl_ops *dcbnl_ops;
1301 #endif 1301 #endif
1302 u8 num_tc; 1302 u8 num_tc;
1303 struct netdev_tc_txq tc_to_txq[TC_MAX_QUEUE]; 1303 struct netdev_tc_txq tc_to_txq[TC_MAX_QUEUE];
1304 u8 prio_tc_map[TC_BITMASK + 1]; 1304 u8 prio_tc_map[TC_BITMASK + 1];
1305 1305
1306 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE) 1306 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
1307 /* max exchange id for FCoE LRO by ddp */ 1307 /* max exchange id for FCoE LRO by ddp */
1308 unsigned int fcoe_ddp_xid; 1308 unsigned int fcoe_ddp_xid;
1309 #endif 1309 #endif
1310 /* phy device may attach itself for hardware timestamping */ 1310 /* phy device may attach itself for hardware timestamping */
1311 struct phy_device *phydev; 1311 struct phy_device *phydev;
1312 1312
1313 /* group the device belongs to */ 1313 /* group the device belongs to */
1314 int group; 1314 int group;
1315 }; 1315 };
1316 #define to_net_dev(d) container_of(d, struct net_device, dev) 1316 #define to_net_dev(d) container_of(d, struct net_device, dev)
1317 1317
1318 #define NETDEV_ALIGN 32 1318 #define NETDEV_ALIGN 32
1319 1319
1320 static inline 1320 static inline
1321 int netdev_get_prio_tc_map(const struct net_device *dev, u32 prio) 1321 int netdev_get_prio_tc_map(const struct net_device *dev, u32 prio)
1322 { 1322 {
1323 return dev->prio_tc_map[prio & TC_BITMASK]; 1323 return dev->prio_tc_map[prio & TC_BITMASK];
1324 } 1324 }
1325 1325
1326 static inline 1326 static inline
1327 int netdev_set_prio_tc_map(struct net_device *dev, u8 prio, u8 tc) 1327 int netdev_set_prio_tc_map(struct net_device *dev, u8 prio, u8 tc)
1328 { 1328 {
1329 if (tc >= dev->num_tc) 1329 if (tc >= dev->num_tc)
1330 return -EINVAL; 1330 return -EINVAL;
1331 1331
1332 dev->prio_tc_map[prio & TC_BITMASK] = tc & TC_BITMASK; 1332 dev->prio_tc_map[prio & TC_BITMASK] = tc & TC_BITMASK;
1333 return 0; 1333 return 0;
1334 } 1334 }
1335 1335
1336 static inline 1336 static inline
1337 void netdev_reset_tc(struct net_device *dev) 1337 void netdev_reset_tc(struct net_device *dev)
1338 { 1338 {
1339 dev->num_tc = 0; 1339 dev->num_tc = 0;
1340 memset(dev->tc_to_txq, 0, sizeof(dev->tc_to_txq)); 1340 memset(dev->tc_to_txq, 0, sizeof(dev->tc_to_txq));
1341 memset(dev->prio_tc_map, 0, sizeof(dev->prio_tc_map)); 1341 memset(dev->prio_tc_map, 0, sizeof(dev->prio_tc_map));
1342 } 1342 }
1343 1343
1344 static inline 1344 static inline
1345 int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset) 1345 int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset)
1346 { 1346 {
1347 if (tc >= dev->num_tc) 1347 if (tc >= dev->num_tc)
1348 return -EINVAL; 1348 return -EINVAL;
1349 1349
1350 dev->tc_to_txq[tc].count = count; 1350 dev->tc_to_txq[tc].count = count;
1351 dev->tc_to_txq[tc].offset = offset; 1351 dev->tc_to_txq[tc].offset = offset;
1352 return 0; 1352 return 0;
1353 } 1353 }
1354 1354
1355 static inline 1355 static inline
1356 int netdev_set_num_tc(struct net_device *dev, u8 num_tc) 1356 int netdev_set_num_tc(struct net_device *dev, u8 num_tc)
1357 { 1357 {
1358 if (num_tc > TC_MAX_QUEUE) 1358 if (num_tc > TC_MAX_QUEUE)
1359 return -EINVAL; 1359 return -EINVAL;
1360 1360
1361 dev->num_tc = num_tc; 1361 dev->num_tc = num_tc;
1362 return 0; 1362 return 0;
1363 } 1363 }
1364 1364
1365 static inline 1365 static inline
1366 int netdev_get_num_tc(struct net_device *dev) 1366 int netdev_get_num_tc(struct net_device *dev)
1367 { 1367 {
1368 return dev->num_tc; 1368 return dev->num_tc;
1369 } 1369 }
1370 1370
1371 static inline 1371 static inline
1372 struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev, 1372 struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
1373 unsigned int index) 1373 unsigned int index)
1374 { 1374 {
1375 return &dev->_tx[index]; 1375 return &dev->_tx[index];
1376 } 1376 }
1377 1377
1378 static inline void netdev_for_each_tx_queue(struct net_device *dev, 1378 static inline void netdev_for_each_tx_queue(struct net_device *dev,
1379 void (*f)(struct net_device *, 1379 void (*f)(struct net_device *,
1380 struct netdev_queue *, 1380 struct netdev_queue *,
1381 void *), 1381 void *),
1382 void *arg) 1382 void *arg)
1383 { 1383 {
1384 unsigned int i; 1384 unsigned int i;
1385 1385
1386 for (i = 0; i < dev->num_tx_queues; i++) 1386 for (i = 0; i < dev->num_tx_queues; i++)
1387 f(dev, &dev->_tx[i], arg); 1387 f(dev, &dev->_tx[i], arg);
1388 } 1388 }
1389 1389
1390 /* 1390 /*
1391 * Net namespace inlines 1391 * Net namespace inlines
1392 */ 1392 */
1393 static inline 1393 static inline
1394 struct net *dev_net(const struct net_device *dev) 1394 struct net *dev_net(const struct net_device *dev)
1395 { 1395 {
1396 return read_pnet(&dev->nd_net); 1396 return read_pnet(&dev->nd_net);
1397 } 1397 }
1398 1398
1399 static inline 1399 static inline
1400 void dev_net_set(struct net_device *dev, struct net *net) 1400 void dev_net_set(struct net_device *dev, struct net *net)
1401 { 1401 {
1402 #ifdef CONFIG_NET_NS 1402 #ifdef CONFIG_NET_NS
1403 release_net(dev->nd_net); 1403 release_net(dev->nd_net);
1404 dev->nd_net = hold_net(net); 1404 dev->nd_net = hold_net(net);
1405 #endif 1405 #endif
1406 } 1406 }
1407 1407
1408 static inline bool netdev_uses_dsa_tags(struct net_device *dev) 1408 static inline bool netdev_uses_dsa_tags(struct net_device *dev)
1409 { 1409 {
1410 #ifdef CONFIG_NET_DSA_TAG_DSA 1410 #ifdef CONFIG_NET_DSA_TAG_DSA
1411 if (dev->dsa_ptr != NULL) 1411 if (dev->dsa_ptr != NULL)
1412 return dsa_uses_dsa_tags(dev->dsa_ptr); 1412 return dsa_uses_dsa_tags(dev->dsa_ptr);
1413 #endif 1413 #endif
1414 1414
1415 return 0; 1415 return 0;
1416 } 1416 }
1417 1417
1418 #ifndef CONFIG_NET_NS 1418 #ifndef CONFIG_NET_NS
1419 static inline void skb_set_dev(struct sk_buff *skb, struct net_device *dev) 1419 static inline void skb_set_dev(struct sk_buff *skb, struct net_device *dev)
1420 { 1420 {
1421 skb->dev = dev; 1421 skb->dev = dev;
1422 } 1422 }
1423 #else /* CONFIG_NET_NS */ 1423 #else /* CONFIG_NET_NS */
1424 void skb_set_dev(struct sk_buff *skb, struct net_device *dev); 1424 void skb_set_dev(struct sk_buff *skb, struct net_device *dev);
1425 #endif 1425 #endif
1426 1426
1427 static inline bool netdev_uses_trailer_tags(struct net_device *dev) 1427 static inline bool netdev_uses_trailer_tags(struct net_device *dev)
1428 { 1428 {
1429 #ifdef CONFIG_NET_DSA_TAG_TRAILER 1429 #ifdef CONFIG_NET_DSA_TAG_TRAILER
1430 if (dev->dsa_ptr != NULL) 1430 if (dev->dsa_ptr != NULL)
1431 return dsa_uses_trailer_tags(dev->dsa_ptr); 1431 return dsa_uses_trailer_tags(dev->dsa_ptr);
1432 #endif 1432 #endif
1433 1433
1434 return 0; 1434 return 0;
1435 } 1435 }
1436 1436
1437 /** 1437 /**
1438 * netdev_priv - access network device private data 1438 * netdev_priv - access network device private data
1439 * @dev: network device 1439 * @dev: network device
1440 * 1440 *
1441 * Get network device private data 1441 * Get network device private data
1442 */ 1442 */
1443 static inline void *netdev_priv(const struct net_device *dev) 1443 static inline void *netdev_priv(const struct net_device *dev)
1444 { 1444 {
1445 return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN); 1445 return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
1446 } 1446 }
1447 1447
1448 /* Set the sysfs physical device reference for the network logical device 1448 /* Set the sysfs physical device reference for the network logical device
1449 * if set prior to registration will cause a symlink during initialization. 1449 * if set prior to registration will cause a symlink during initialization.
1450 */ 1450 */
1451 #define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev)) 1451 #define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))
1452 1452
1453 /* Set the sysfs device type for the network logical device to allow 1453 /* Set the sysfs device type for the network logical device to allow
1454 * fin grained indentification of different network device types. For 1454 * fin grained indentification of different network device types. For
1455 * example Ethernet, Wirelss LAN, Bluetooth, WiMAX etc. 1455 * example Ethernet, Wirelss LAN, Bluetooth, WiMAX etc.
1456 */ 1456 */
1457 #define SET_NETDEV_DEVTYPE(net, devtype) ((net)->dev.type = (devtype)) 1457 #define SET_NETDEV_DEVTYPE(net, devtype) ((net)->dev.type = (devtype))
1458 1458
1459 /** 1459 /**
1460 * netif_napi_add - initialize a napi context 1460 * netif_napi_add - initialize a napi context
1461 * @dev: network device 1461 * @dev: network device
1462 * @napi: napi context 1462 * @napi: napi context
1463 * @poll: polling function 1463 * @poll: polling function
1464 * @weight: default weight 1464 * @weight: default weight
1465 * 1465 *
1466 * netif_napi_add() must be used to initialize a napi context prior to calling 1466 * netif_napi_add() must be used to initialize a napi context prior to calling
1467 * *any* of the other napi related functions. 1467 * *any* of the other napi related functions.
1468 */ 1468 */
1469 void netif_napi_add(struct net_device *dev, struct napi_struct *napi, 1469 void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
1470 int (*poll)(struct napi_struct *, int), int weight); 1470 int (*poll)(struct napi_struct *, int), int weight);
1471 1471
1472 /** 1472 /**
1473 * netif_napi_del - remove a napi context 1473 * netif_napi_del - remove a napi context
1474 * @napi: napi context 1474 * @napi: napi context
1475 * 1475 *
1476 * netif_napi_del() removes a napi context from the network device napi list 1476 * netif_napi_del() removes a napi context from the network device napi list
1477 */ 1477 */
1478 void netif_napi_del(struct napi_struct *napi); 1478 void netif_napi_del(struct napi_struct *napi);
1479 1479
1480 struct napi_gro_cb { 1480 struct napi_gro_cb {
1481 /* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */ 1481 /* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */
1482 void *frag0; 1482 void *frag0;
1483 1483
1484 /* Length of frag0. */ 1484 /* Length of frag0. */
1485 unsigned int frag0_len; 1485 unsigned int frag0_len;
1486 1486
1487 /* This indicates where we are processing relative to skb->data. */ 1487 /* This indicates where we are processing relative to skb->data. */
1488 int data_offset; 1488 int data_offset;
1489 1489
1490 /* This is non-zero if the packet may be of the same flow. */ 1490 /* This is non-zero if the packet may be of the same flow. */
1491 int same_flow; 1491 int same_flow;
1492 1492
1493 /* This is non-zero if the packet cannot be merged with the new skb. */ 1493 /* This is non-zero if the packet cannot be merged with the new skb. */
1494 int flush; 1494 int flush;
1495 1495
1496 /* Number of segments aggregated. */ 1496 /* Number of segments aggregated. */
1497 int count; 1497 int count;
1498 1498
1499 /* Free the skb? */ 1499 /* Free the skb? */
1500 int free; 1500 int free;
1501 }; 1501 };
1502 1502
1503 #define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb) 1503 #define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)
1504 1504
1505 struct packet_type { 1505 struct packet_type {
1506 __be16 type; /* This is really htons(ether_type). */ 1506 __be16 type; /* This is really htons(ether_type). */
1507 struct net_device *dev; /* NULL is wildcarded here */ 1507 struct net_device *dev; /* NULL is wildcarded here */
1508 int (*func) (struct sk_buff *, 1508 int (*func) (struct sk_buff *,
1509 struct net_device *, 1509 struct net_device *,
1510 struct packet_type *, 1510 struct packet_type *,
1511 struct net_device *); 1511 struct net_device *);
1512 struct sk_buff *(*gso_segment)(struct sk_buff *skb, 1512 struct sk_buff *(*gso_segment)(struct sk_buff *skb,
1513 u32 features); 1513 u32 features);
1514 int (*gso_send_check)(struct sk_buff *skb); 1514 int (*gso_send_check)(struct sk_buff *skb);
1515 struct sk_buff **(*gro_receive)(struct sk_buff **head, 1515 struct sk_buff **(*gro_receive)(struct sk_buff **head,
1516 struct sk_buff *skb); 1516 struct sk_buff *skb);
1517 int (*gro_complete)(struct sk_buff *skb); 1517 int (*gro_complete)(struct sk_buff *skb);
1518 void *af_packet_priv; 1518 void *af_packet_priv;
1519 struct list_head list; 1519 struct list_head list;
1520 }; 1520 };
1521 1521
1522 #include <linux/notifier.h> 1522 #include <linux/notifier.h>
1523 1523
1524 /* netdevice notifier chain. Please remember to update the rtnetlink 1524 /* netdevice notifier chain. Please remember to update the rtnetlink
1525 * notification exclusion list in rtnetlink_event() when adding new 1525 * notification exclusion list in rtnetlink_event() when adding new
1526 * types. 1526 * types.
1527 */ 1527 */
1528 #define NETDEV_UP 0x0001 /* For now you can't veto a device up/down */ 1528 #define NETDEV_UP 0x0001 /* For now you can't veto a device up/down */
1529 #define NETDEV_DOWN 0x0002 1529 #define NETDEV_DOWN 0x0002
1530 #define NETDEV_REBOOT 0x0003 /* Tell a protocol stack a network interface 1530 #define NETDEV_REBOOT 0x0003 /* Tell a protocol stack a network interface
1531 detected a hardware crash and restarted 1531 detected a hardware crash and restarted
1532 - we can use this eg to kick tcp sessions 1532 - we can use this eg to kick tcp sessions
1533 once done */ 1533 once done */
1534 #define NETDEV_CHANGE 0x0004 /* Notify device state change */ 1534 #define NETDEV_CHANGE 0x0004 /* Notify device state change */
1535 #define NETDEV_REGISTER 0x0005 1535 #define NETDEV_REGISTER 0x0005
1536 #define NETDEV_UNREGISTER 0x0006 1536 #define NETDEV_UNREGISTER 0x0006
1537 #define NETDEV_CHANGEMTU 0x0007 1537 #define NETDEV_CHANGEMTU 0x0007
1538 #define NETDEV_CHANGEADDR 0x0008 1538 #define NETDEV_CHANGEADDR 0x0008
1539 #define NETDEV_GOING_DOWN 0x0009 1539 #define NETDEV_GOING_DOWN 0x0009
1540 #define NETDEV_CHANGENAME 0x000A 1540 #define NETDEV_CHANGENAME 0x000A
1541 #define NETDEV_FEAT_CHANGE 0x000B 1541 #define NETDEV_FEAT_CHANGE 0x000B
1542 #define NETDEV_BONDING_FAILOVER 0x000C 1542 #define NETDEV_BONDING_FAILOVER 0x000C
1543 #define NETDEV_PRE_UP 0x000D 1543 #define NETDEV_PRE_UP 0x000D
1544 #define NETDEV_PRE_TYPE_CHANGE 0x000E 1544 #define NETDEV_PRE_TYPE_CHANGE 0x000E
1545 #define NETDEV_POST_TYPE_CHANGE 0x000F 1545 #define NETDEV_POST_TYPE_CHANGE 0x000F
1546 #define NETDEV_POST_INIT 0x0010 1546 #define NETDEV_POST_INIT 0x0010
1547 #define NETDEV_UNREGISTER_BATCH 0x0011 1547 #define NETDEV_UNREGISTER_BATCH 0x0011
1548 #define NETDEV_RELEASE 0x0012 1548 #define NETDEV_RELEASE 0x0012
1549 #define NETDEV_NOTIFY_PEERS 0x0013 1549 #define NETDEV_NOTIFY_PEERS 0x0013
1550 #define NETDEV_JOIN 0x0014 1550 #define NETDEV_JOIN 0x0014
1551 1551
1552 extern int register_netdevice_notifier(struct notifier_block *nb); 1552 extern int register_netdevice_notifier(struct notifier_block *nb);
1553 extern int unregister_netdevice_notifier(struct notifier_block *nb); 1553 extern int unregister_netdevice_notifier(struct notifier_block *nb);
1554 extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev); 1554 extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
1555 1555
1556 1556
1557 extern rwlock_t dev_base_lock; /* Device list lock */ 1557 extern rwlock_t dev_base_lock; /* Device list lock */
1558 1558
1559 1559
1560 #define for_each_netdev(net, d) \ 1560 #define for_each_netdev(net, d) \
1561 list_for_each_entry(d, &(net)->dev_base_head, dev_list) 1561 list_for_each_entry(d, &(net)->dev_base_head, dev_list)
1562 #define for_each_netdev_reverse(net, d) \ 1562 #define for_each_netdev_reverse(net, d) \
1563 list_for_each_entry_reverse(d, &(net)->dev_base_head, dev_list) 1563 list_for_each_entry_reverse(d, &(net)->dev_base_head, dev_list)
1564 #define for_each_netdev_rcu(net, d) \ 1564 #define for_each_netdev_rcu(net, d) \
1565 list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list) 1565 list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list)
1566 #define for_each_netdev_safe(net, d, n) \ 1566 #define for_each_netdev_safe(net, d, n) \
1567 list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list) 1567 list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
1568 #define for_each_netdev_continue(net, d) \ 1568 #define for_each_netdev_continue(net, d) \
1569 list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list) 1569 list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
1570 #define for_each_netdev_continue_rcu(net, d) \ 1570 #define for_each_netdev_continue_rcu(net, d) \
1571 list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list) 1571 list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list)
1572 #define net_device_entry(lh) list_entry(lh, struct net_device, dev_list) 1572 #define net_device_entry(lh) list_entry(lh, struct net_device, dev_list)
1573 1573
1574 static inline struct net_device *next_net_device(struct net_device *dev) 1574 static inline struct net_device *next_net_device(struct net_device *dev)
1575 { 1575 {
1576 struct list_head *lh; 1576 struct list_head *lh;
1577 struct net *net; 1577 struct net *net;
1578 1578
1579 net = dev_net(dev); 1579 net = dev_net(dev);
1580 lh = dev->dev_list.next; 1580 lh = dev->dev_list.next;
1581 return lh == &net->dev_base_head ? NULL : net_device_entry(lh); 1581 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
1582 } 1582 }
1583 1583
1584 static inline struct net_device *next_net_device_rcu(struct net_device *dev) 1584 static inline struct net_device *next_net_device_rcu(struct net_device *dev)
1585 { 1585 {
1586 struct list_head *lh; 1586 struct list_head *lh;
1587 struct net *net; 1587 struct net *net;
1588 1588
1589 net = dev_net(dev); 1589 net = dev_net(dev);
1590 lh = rcu_dereference(list_next_rcu(&dev->dev_list)); 1590 lh = rcu_dereference(list_next_rcu(&dev->dev_list));
1591 return lh == &net->dev_base_head ? NULL : net_device_entry(lh); 1591 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
1592 } 1592 }
1593 1593
1594 static inline struct net_device *first_net_device(struct net *net) 1594 static inline struct net_device *first_net_device(struct net *net)
1595 { 1595 {
1596 return list_empty(&net->dev_base_head) ? NULL : 1596 return list_empty(&net->dev_base_head) ? NULL :
1597 net_device_entry(net->dev_base_head.next); 1597 net_device_entry(net->dev_base_head.next);
1598 } 1598 }
1599 1599
1600 static inline struct net_device *first_net_device_rcu(struct net *net) 1600 static inline struct net_device *first_net_device_rcu(struct net *net)
1601 { 1601 {
1602 struct list_head *lh = rcu_dereference(list_next_rcu(&net->dev_base_head)); 1602 struct list_head *lh = rcu_dereference(list_next_rcu(&net->dev_base_head));
1603 1603
1604 return lh == &net->dev_base_head ? NULL : net_device_entry(lh); 1604 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
1605 } 1605 }
1606 1606
1607 extern int netdev_boot_setup_check(struct net_device *dev); 1607 extern int netdev_boot_setup_check(struct net_device *dev);
1608 extern unsigned long netdev_boot_base(const char *prefix, int unit); 1608 extern unsigned long netdev_boot_base(const char *prefix, int unit);
1609 extern struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type, 1609 extern struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
1610 const char *hwaddr); 1610 const char *hwaddr);
1611 extern struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type); 1611 extern struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
1612 extern struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type); 1612 extern struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);
1613 extern void dev_add_pack(struct packet_type *pt); 1613 extern void dev_add_pack(struct packet_type *pt);
1614 extern void dev_remove_pack(struct packet_type *pt); 1614 extern void dev_remove_pack(struct packet_type *pt);
1615 extern void __dev_remove_pack(struct packet_type *pt); 1615 extern void __dev_remove_pack(struct packet_type *pt);
1616 1616
1617 extern struct net_device *dev_get_by_flags_rcu(struct net *net, unsigned short flags, 1617 extern struct net_device *dev_get_by_flags_rcu(struct net *net, unsigned short flags,
1618 unsigned short mask); 1618 unsigned short mask);
1619 extern struct net_device *dev_get_by_name(struct net *net, const char *name); 1619 extern struct net_device *dev_get_by_name(struct net *net, const char *name);
1620 extern struct net_device *dev_get_by_name_rcu(struct net *net, const char *name); 1620 extern struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);
1621 extern struct net_device *__dev_get_by_name(struct net *net, const char *name); 1621 extern struct net_device *__dev_get_by_name(struct net *net, const char *name);
1622 extern int dev_alloc_name(struct net_device *dev, const char *name); 1622 extern int dev_alloc_name(struct net_device *dev, const char *name);
1623 extern int dev_open(struct net_device *dev); 1623 extern int dev_open(struct net_device *dev);
1624 extern int dev_close(struct net_device *dev); 1624 extern int dev_close(struct net_device *dev);
1625 extern void dev_disable_lro(struct net_device *dev); 1625 extern void dev_disable_lro(struct net_device *dev);
1626 extern int dev_queue_xmit(struct sk_buff *skb); 1626 extern int dev_queue_xmit(struct sk_buff *skb);
1627 extern int register_netdevice(struct net_device *dev); 1627 extern int register_netdevice(struct net_device *dev);
1628 extern void unregister_netdevice_queue(struct net_device *dev, 1628 extern void unregister_netdevice_queue(struct net_device *dev,
1629 struct list_head *head); 1629 struct list_head *head);
1630 extern void unregister_netdevice_many(struct list_head *head); 1630 extern void unregister_netdevice_many(struct list_head *head);
1631 static inline void unregister_netdevice(struct net_device *dev) 1631 static inline void unregister_netdevice(struct net_device *dev)
1632 { 1632 {
1633 unregister_netdevice_queue(dev, NULL); 1633 unregister_netdevice_queue(dev, NULL);
1634 } 1634 }
1635 1635
1636 extern int netdev_refcnt_read(const struct net_device *dev); 1636 extern int netdev_refcnt_read(const struct net_device *dev);
1637 extern void free_netdev(struct net_device *dev); 1637 extern void free_netdev(struct net_device *dev);
1638 extern void synchronize_net(void); 1638 extern void synchronize_net(void);
1639 extern int init_dummy_netdev(struct net_device *dev); 1639 extern int init_dummy_netdev(struct net_device *dev);
1640 extern void netdev_resync_ops(struct net_device *dev); 1640 extern void netdev_resync_ops(struct net_device *dev);
1641 1641
1642 extern struct net_device *dev_get_by_index(struct net *net, int ifindex); 1642 extern struct net_device *dev_get_by_index(struct net *net, int ifindex);
1643 extern struct net_device *__dev_get_by_index(struct net *net, int ifindex); 1643 extern struct net_device *__dev_get_by_index(struct net *net, int ifindex);
1644 extern struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex); 1644 extern struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);
1645 extern int dev_restart(struct net_device *dev); 1645 extern int dev_restart(struct net_device *dev);
1646 #ifdef CONFIG_NETPOLL_TRAP 1646 #ifdef CONFIG_NETPOLL_TRAP
1647 extern int netpoll_trap(void); 1647 extern int netpoll_trap(void);
1648 #endif 1648 #endif
1649 extern int skb_gro_receive(struct sk_buff **head, 1649 extern int skb_gro_receive(struct sk_buff **head,
1650 struct sk_buff *skb); 1650 struct sk_buff *skb);
1651 extern void skb_gro_reset_offset(struct sk_buff *skb); 1651 extern void skb_gro_reset_offset(struct sk_buff *skb);
1652 1652
1653 static inline unsigned int skb_gro_offset(const struct sk_buff *skb) 1653 static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
1654 { 1654 {
1655 return NAPI_GRO_CB(skb)->data_offset; 1655 return NAPI_GRO_CB(skb)->data_offset;
1656 } 1656 }
1657 1657
1658 static inline unsigned int skb_gro_len(const struct sk_buff *skb) 1658 static inline unsigned int skb_gro_len(const struct sk_buff *skb)
1659 { 1659 {
1660 return skb->len - NAPI_GRO_CB(skb)->data_offset; 1660 return skb->len - NAPI_GRO_CB(skb)->data_offset;
1661 } 1661 }
1662 1662
1663 static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len) 1663 static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)
1664 { 1664 {
1665 NAPI_GRO_CB(skb)->data_offset += len; 1665 NAPI_GRO_CB(skb)->data_offset += len;
1666 } 1666 }
1667 1667
1668 static inline void *skb_gro_header_fast(struct sk_buff *skb, 1668 static inline void *skb_gro_header_fast(struct sk_buff *skb,
1669 unsigned int offset) 1669 unsigned int offset)
1670 { 1670 {
1671 return NAPI_GRO_CB(skb)->frag0 + offset; 1671 return NAPI_GRO_CB(skb)->frag0 + offset;
1672 } 1672 }
1673 1673
1674 static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen) 1674 static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
1675 { 1675 {
1676 return NAPI_GRO_CB(skb)->frag0_len < hlen; 1676 return NAPI_GRO_CB(skb)->frag0_len < hlen;
1677 } 1677 }
1678 1678
1679 static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen, 1679 static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
1680 unsigned int offset) 1680 unsigned int offset)
1681 { 1681 {
1682 if (!pskb_may_pull(skb, hlen)) 1682 if (!pskb_may_pull(skb, hlen))
1683 return NULL; 1683 return NULL;
1684 1684
1685 NAPI_GRO_CB(skb)->frag0 = NULL; 1685 NAPI_GRO_CB(skb)->frag0 = NULL;
1686 NAPI_GRO_CB(skb)->frag0_len = 0; 1686 NAPI_GRO_CB(skb)->frag0_len = 0;
1687 return skb->data + offset; 1687 return skb->data + offset;
1688 } 1688 }
1689 1689
1690 static inline void *skb_gro_mac_header(struct sk_buff *skb) 1690 static inline void *skb_gro_mac_header(struct sk_buff *skb)
1691 { 1691 {
1692 return NAPI_GRO_CB(skb)->frag0 ?: skb_mac_header(skb); 1692 return NAPI_GRO_CB(skb)->frag0 ?: skb_mac_header(skb);
1693 } 1693 }
1694 1694
1695 static inline void *skb_gro_network_header(struct sk_buff *skb) 1695 static inline void *skb_gro_network_header(struct sk_buff *skb)
1696 { 1696 {
1697 return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) + 1697 return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +
1698 skb_network_offset(skb); 1698 skb_network_offset(skb);
1699 } 1699 }
1700 1700
1701 static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev, 1701 static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
1702 unsigned short type, 1702 unsigned short type,
1703 const void *daddr, const void *saddr, 1703 const void *daddr, const void *saddr,
1704 unsigned len) 1704 unsigned len)
1705 { 1705 {
1706 if (!dev->header_ops || !dev->header_ops->create) 1706 if (!dev->header_ops || !dev->header_ops->create)
1707 return 0; 1707 return 0;
1708 1708
1709 return dev->header_ops->create(skb, dev, type, daddr, saddr, len); 1709 return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
1710 } 1710 }
1711 1711
1712 static inline int dev_parse_header(const struct sk_buff *skb, 1712 static inline int dev_parse_header(const struct sk_buff *skb,
1713 unsigned char *haddr) 1713 unsigned char *haddr)
1714 { 1714 {
1715 const struct net_device *dev = skb->dev; 1715 const struct net_device *dev = skb->dev;
1716 1716
1717 if (!dev->header_ops || !dev->header_ops->parse) 1717 if (!dev->header_ops || !dev->header_ops->parse)
1718 return 0; 1718 return 0;
1719 return dev->header_ops->parse(skb, haddr); 1719 return dev->header_ops->parse(skb, haddr);
1720 } 1720 }
1721 1721
1722 typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len); 1722 typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
1723 extern int register_gifconf(unsigned int family, gifconf_func_t * gifconf); 1723 extern int register_gifconf(unsigned int family, gifconf_func_t * gifconf);
1724 static inline int unregister_gifconf(unsigned int family) 1724 static inline int unregister_gifconf(unsigned int family)
1725 { 1725 {
1726 return register_gifconf(family, NULL); 1726 return register_gifconf(family, NULL);
1727 } 1727 }
1728 1728
1729 /* 1729 /*
1730 * Incoming packets are placed on per-cpu queues 1730 * Incoming packets are placed on per-cpu queues
1731 */ 1731 */
1732 struct softnet_data { 1732 struct softnet_data {
1733 struct Qdisc *output_queue; 1733 struct Qdisc *output_queue;
1734 struct Qdisc **output_queue_tailp; 1734 struct Qdisc **output_queue_tailp;
1735 struct list_head poll_list; 1735 struct list_head poll_list;
1736 struct sk_buff *completion_queue; 1736 struct sk_buff *completion_queue;
1737 struct sk_buff_head process_queue; 1737 struct sk_buff_head process_queue;
1738 1738
1739 /* stats */ 1739 /* stats */
1740 unsigned int processed; 1740 unsigned int processed;
1741 unsigned int time_squeeze; 1741 unsigned int time_squeeze;
1742 unsigned int cpu_collision; 1742 unsigned int cpu_collision;
1743 unsigned int received_rps; 1743 unsigned int received_rps;
1744 1744
1745 #ifdef CONFIG_RPS 1745 #ifdef CONFIG_RPS
1746 struct softnet_data *rps_ipi_list; 1746 struct softnet_data *rps_ipi_list;
1747 1747
1748 /* Elements below can be accessed between CPUs for RPS */ 1748 /* Elements below can be accessed between CPUs for RPS */
1749 struct call_single_data csd ____cacheline_aligned_in_smp; 1749 struct call_single_data csd ____cacheline_aligned_in_smp;
1750 struct softnet_data *rps_ipi_next; 1750 struct softnet_data *rps_ipi_next;
1751 unsigned int cpu; 1751 unsigned int cpu;
1752 unsigned int input_queue_head; 1752 unsigned int input_queue_head;
1753 unsigned int input_queue_tail; 1753 unsigned int input_queue_tail;
1754 #endif 1754 #endif
1755 unsigned dropped; 1755 unsigned dropped;
1756 struct sk_buff_head input_pkt_queue; 1756 struct sk_buff_head input_pkt_queue;
1757 struct napi_struct backlog; 1757 struct napi_struct backlog;
1758 }; 1758 };
1759 1759
1760 static inline void input_queue_head_incr(struct softnet_data *sd) 1760 static inline void input_queue_head_incr(struct softnet_data *sd)
1761 { 1761 {
1762 #ifdef CONFIG_RPS 1762 #ifdef CONFIG_RPS
1763 sd->input_queue_head++; 1763 sd->input_queue_head++;
1764 #endif 1764 #endif
1765 } 1765 }
1766 1766
1767 static inline void input_queue_tail_incr_save(struct softnet_data *sd, 1767 static inline void input_queue_tail_incr_save(struct softnet_data *sd,
1768 unsigned int *qtail) 1768 unsigned int *qtail)
1769 { 1769 {
1770 #ifdef CONFIG_RPS 1770 #ifdef CONFIG_RPS
1771 *qtail = ++sd->input_queue_tail; 1771 *qtail = ++sd->input_queue_tail;
1772 #endif 1772 #endif
1773 } 1773 }
1774 1774
1775 DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data); 1775 DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
1776 1776
1777 extern void __netif_schedule(struct Qdisc *q); 1777 extern void __netif_schedule(struct Qdisc *q);
1778 1778
1779 static inline void netif_schedule_queue(struct netdev_queue *txq) 1779 static inline void netif_schedule_queue(struct netdev_queue *txq)
1780 { 1780 {
1781 if (!test_bit(__QUEUE_STATE_XOFF, &txq->state)) 1781 if (!test_bit(__QUEUE_STATE_XOFF, &txq->state))
1782 __netif_schedule(txq->qdisc); 1782 __netif_schedule(txq->qdisc);
1783 } 1783 }
1784 1784
1785 static inline void netif_tx_schedule_all(struct net_device *dev) 1785 static inline void netif_tx_schedule_all(struct net_device *dev)
1786 { 1786 {
1787 unsigned int i; 1787 unsigned int i;
1788 1788
1789 for (i = 0; i < dev->num_tx_queues; i++) 1789 for (i = 0; i < dev->num_tx_queues; i++)
1790 netif_schedule_queue(netdev_get_tx_queue(dev, i)); 1790 netif_schedule_queue(netdev_get_tx_queue(dev, i));
1791 } 1791 }
1792 1792
1793 static inline void netif_tx_start_queue(struct netdev_queue *dev_queue) 1793 static inline void netif_tx_start_queue(struct netdev_queue *dev_queue)
1794 { 1794 {
1795 clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state); 1795 clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
1796 } 1796 }
1797 1797
1798 /** 1798 /**
1799 * netif_start_queue - allow transmit 1799 * netif_start_queue - allow transmit
1800 * @dev: network device 1800 * @dev: network device
1801 * 1801 *
1802 * Allow upper layers to call the device hard_start_xmit routine. 1802 * Allow upper layers to call the device hard_start_xmit routine.
1803 */ 1803 */
1804 static inline void netif_start_queue(struct net_device *dev) 1804 static inline void netif_start_queue(struct net_device *dev)
1805 { 1805 {
1806 netif_tx_start_queue(netdev_get_tx_queue(dev, 0)); 1806 netif_tx_start_queue(netdev_get_tx_queue(dev, 0));
1807 } 1807 }
1808 1808
1809 static inline void netif_tx_start_all_queues(struct net_device *dev) 1809 static inline void netif_tx_start_all_queues(struct net_device *dev)
1810 { 1810 {
1811 unsigned int i; 1811 unsigned int i;
1812 1812
1813 for (i = 0; i < dev->num_tx_queues; i++) { 1813 for (i = 0; i < dev->num_tx_queues; i++) {
1814 struct netdev_queue *txq = netdev_get_tx_queue(dev, i); 1814 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1815 netif_tx_start_queue(txq); 1815 netif_tx_start_queue(txq);
1816 } 1816 }
1817 } 1817 }
1818 1818
1819 static inline void netif_tx_wake_queue(struct netdev_queue *dev_queue) 1819 static inline void netif_tx_wake_queue(struct netdev_queue *dev_queue)
1820 { 1820 {
1821 #ifdef CONFIG_NETPOLL_TRAP 1821 #ifdef CONFIG_NETPOLL_TRAP
1822 if (netpoll_trap()) { 1822 if (netpoll_trap()) {
1823 netif_tx_start_queue(dev_queue); 1823 netif_tx_start_queue(dev_queue);
1824 return; 1824 return;
1825 } 1825 }
1826 #endif 1826 #endif
1827 if (test_and_clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state)) 1827 if (test_and_clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state))
1828 __netif_schedule(dev_queue->qdisc); 1828 __netif_schedule(dev_queue->qdisc);
1829 } 1829 }
1830 1830
1831 /** 1831 /**
1832 * netif_wake_queue - restart transmit 1832 * netif_wake_queue - restart transmit
1833 * @dev: network device 1833 * @dev: network device
1834 * 1834 *
1835 * Allow upper layers to call the device hard_start_xmit routine. 1835 * Allow upper layers to call the device hard_start_xmit routine.
1836 * Used for flow control when transmit resources are available. 1836 * Used for flow control when transmit resources are available.
1837 */ 1837 */
1838 static inline void netif_wake_queue(struct net_device *dev) 1838 static inline void netif_wake_queue(struct net_device *dev)
1839 { 1839 {
1840 netif_tx_wake_queue(netdev_get_tx_queue(dev, 0)); 1840 netif_tx_wake_queue(netdev_get_tx_queue(dev, 0));
1841 } 1841 }
1842 1842
1843 static inline void netif_tx_wake_all_queues(struct net_device *dev) 1843 static inline void netif_tx_wake_all_queues(struct net_device *dev)
1844 { 1844 {
1845 unsigned int i; 1845 unsigned int i;
1846 1846
1847 for (i = 0; i < dev->num_tx_queues; i++) { 1847 for (i = 0; i < dev->num_tx_queues; i++) {
1848 struct netdev_queue *txq = netdev_get_tx_queue(dev, i); 1848 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1849 netif_tx_wake_queue(txq); 1849 netif_tx_wake_queue(txq);
1850 } 1850 }
1851 } 1851 }
1852 1852
1853 static inline void netif_tx_stop_queue(struct netdev_queue *dev_queue) 1853 static inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
1854 { 1854 {
1855 if (WARN_ON(!dev_queue)) { 1855 if (WARN_ON(!dev_queue)) {
1856 pr_info("netif_stop_queue() cannot be called before register_netdev()\n"); 1856 pr_info("netif_stop_queue() cannot be called before register_netdev()\n");
1857 return; 1857 return;
1858 } 1858 }
1859 set_bit(__QUEUE_STATE_XOFF, &dev_queue->state); 1859 set_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
1860 } 1860 }
1861 1861
1862 /** 1862 /**
1863 * netif_stop_queue - stop transmitted packets 1863 * netif_stop_queue - stop transmitted packets
1864 * @dev: network device 1864 * @dev: network device
1865 * 1865 *
1866 * Stop upper layers calling the device hard_start_xmit routine. 1866 * Stop upper layers calling the device hard_start_xmit routine.
1867 * Used for flow control when transmit resources are unavailable. 1867 * Used for flow control when transmit resources are unavailable.
1868 */ 1868 */
1869 static inline void netif_stop_queue(struct net_device *dev) 1869 static inline void netif_stop_queue(struct net_device *dev)
1870 { 1870 {
1871 netif_tx_stop_queue(netdev_get_tx_queue(dev, 0)); 1871 netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));
1872 } 1872 }
1873 1873
1874 static inline void netif_tx_stop_all_queues(struct net_device *dev) 1874 static inline void netif_tx_stop_all_queues(struct net_device *dev)
1875 { 1875 {
1876 unsigned int i; 1876 unsigned int i;
1877 1877
1878 for (i = 0; i < dev->num_tx_queues; i++) { 1878 for (i = 0; i < dev->num_tx_queues; i++) {
1879 struct netdev_queue *txq = netdev_get_tx_queue(dev, i); 1879 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
1880 netif_tx_stop_queue(txq); 1880 netif_tx_stop_queue(txq);
1881 } 1881 }
1882 } 1882 }
1883 1883
1884 static inline int netif_tx_queue_stopped(const struct netdev_queue *dev_queue) 1884 static inline int netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
1885 { 1885 {
1886 return test_bit(__QUEUE_STATE_XOFF, &dev_queue->state); 1886 return test_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
1887 } 1887 }
1888 1888
1889 /** 1889 /**
1890 * netif_queue_stopped - test if transmit queue is flowblocked 1890 * netif_queue_stopped - test if transmit queue is flowblocked
1891 * @dev: network device 1891 * @dev: network device
1892 * 1892 *
1893 * Test if transmit queue on device is currently unable to send. 1893 * Test if transmit queue on device is currently unable to send.
1894 */ 1894 */
1895 static inline int netif_queue_stopped(const struct net_device *dev) 1895 static inline int netif_queue_stopped(const struct net_device *dev)
1896 { 1896 {
1897 return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0)); 1897 return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
1898 } 1898 }
1899 1899
1900 static inline int netif_tx_queue_frozen_or_stopped(const struct netdev_queue *dev_queue) 1900 static inline int netif_tx_queue_frozen_or_stopped(const struct netdev_queue *dev_queue)
1901 { 1901 {
1902 return dev_queue->state & QUEUE_STATE_XOFF_OR_FROZEN; 1902 return dev_queue->state & QUEUE_STATE_XOFF_OR_FROZEN;
1903 } 1903 }
1904 1904
1905 /** 1905 /**
1906 * netif_running - test if up 1906 * netif_running - test if up
1907 * @dev: network device 1907 * @dev: network device
1908 * 1908 *
1909 * Test if the device has been brought up. 1909 * Test if the device has been brought up.
1910 */ 1910 */
1911 static inline int netif_running(const struct net_device *dev) 1911 static inline int netif_running(const struct net_device *dev)
1912 { 1912 {
1913 return test_bit(__LINK_STATE_START, &dev->state); 1913 return test_bit(__LINK_STATE_START, &dev->state);
1914 } 1914 }
1915 1915
1916 /* 1916 /*
1917 * Routines to manage the subqueues on a device. We only need start 1917 * Routines to manage the subqueues on a device. We only need start
1918 * stop, and a check if it's stopped. All other device management is 1918 * stop, and a check if it's stopped. All other device management is
1919 * done at the overall netdevice level. 1919 * done at the overall netdevice level.
1920 * Also test the device if we're multiqueue. 1920 * Also test the device if we're multiqueue.
1921 */ 1921 */
1922 1922
1923 /** 1923 /**
1924 * netif_start_subqueue - allow sending packets on subqueue 1924 * netif_start_subqueue - allow sending packets on subqueue
1925 * @dev: network device 1925 * @dev: network device
1926 * @queue_index: sub queue index 1926 * @queue_index: sub queue index
1927 * 1927 *
1928 * Start individual transmit queue of a device with multiple transmit queues. 1928 * Start individual transmit queue of a device with multiple transmit queues.
1929 */ 1929 */
1930 static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index) 1930 static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
1931 { 1931 {
1932 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index); 1932 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
1933 1933
1934 netif_tx_start_queue(txq); 1934 netif_tx_start_queue(txq);
1935 } 1935 }
1936 1936
1937 /** 1937 /**
1938 * netif_stop_subqueue - stop sending packets on subqueue 1938 * netif_stop_subqueue - stop sending packets on subqueue
1939 * @dev: network device 1939 * @dev: network device
1940 * @queue_index: sub queue index 1940 * @queue_index: sub queue index
1941 * 1941 *
1942 * Stop individual transmit queue of a device with multiple transmit queues. 1942 * Stop individual transmit queue of a device with multiple transmit queues.
1943 */ 1943 */
1944 static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index) 1944 static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
1945 { 1945 {
1946 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index); 1946 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
1947 #ifdef CONFIG_NETPOLL_TRAP 1947 #ifdef CONFIG_NETPOLL_TRAP
1948 if (netpoll_trap()) 1948 if (netpoll_trap())
1949 return; 1949 return;
1950 #endif 1950 #endif
1951 netif_tx_stop_queue(txq); 1951 netif_tx_stop_queue(txq);
1952 } 1952 }
1953 1953
1954 /** 1954 /**
1955 * netif_subqueue_stopped - test status of subqueue 1955 * netif_subqueue_stopped - test status of subqueue
1956 * @dev: network device 1956 * @dev: network device
1957 * @queue_index: sub queue index 1957 * @queue_index: sub queue index
1958 * 1958 *
1959 * Check individual transmit queue of a device with multiple transmit queues. 1959 * Check individual transmit queue of a device with multiple transmit queues.
1960 */ 1960 */
1961 static inline int __netif_subqueue_stopped(const struct net_device *dev, 1961 static inline int __netif_subqueue_stopped(const struct net_device *dev,
1962 u16 queue_index) 1962 u16 queue_index)
1963 { 1963 {
1964 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index); 1964 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
1965 1965
1966 return netif_tx_queue_stopped(txq); 1966 return netif_tx_queue_stopped(txq);
1967 } 1967 }
1968 1968
1969 static inline int netif_subqueue_stopped(const struct net_device *dev, 1969 static inline int netif_subqueue_stopped(const struct net_device *dev,
1970 struct sk_buff *skb) 1970 struct sk_buff *skb)
1971 { 1971 {
1972 return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb)); 1972 return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
1973 } 1973 }
1974 1974
1975 /** 1975 /**
1976 * netif_wake_subqueue - allow sending packets on subqueue 1976 * netif_wake_subqueue - allow sending packets on subqueue
1977 * @dev: network device 1977 * @dev: network device
1978 * @queue_index: sub queue index 1978 * @queue_index: sub queue index
1979 * 1979 *
1980 * Resume individual transmit queue of a device with multiple transmit queues. 1980 * Resume individual transmit queue of a device with multiple transmit queues.
1981 */ 1981 */
1982 static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index) 1982 static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
1983 { 1983 {
1984 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index); 1984 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
1985 #ifdef CONFIG_NETPOLL_TRAP 1985 #ifdef CONFIG_NETPOLL_TRAP
1986 if (netpoll_trap()) 1986 if (netpoll_trap())
1987 return; 1987 return;
1988 #endif 1988 #endif
1989 if (test_and_clear_bit(__QUEUE_STATE_XOFF, &txq->state)) 1989 if (test_and_clear_bit(__QUEUE_STATE_XOFF, &txq->state))
1990 __netif_schedule(txq->qdisc); 1990 __netif_schedule(txq->qdisc);
1991 } 1991 }
1992 1992
1993 /* 1993 /*
1994 * Returns a Tx hash for the given packet when dev->real_num_tx_queues is used 1994 * Returns a Tx hash for the given packet when dev->real_num_tx_queues is used
1995 * as a distribution range limit for the returned value. 1995 * as a distribution range limit for the returned value.
1996 */ 1996 */
1997 static inline u16 skb_tx_hash(const struct net_device *dev, 1997 static inline u16 skb_tx_hash(const struct net_device *dev,
1998 const struct sk_buff *skb) 1998 const struct sk_buff *skb)
1999 { 1999 {
2000 return __skb_tx_hash(dev, skb, dev->real_num_tx_queues); 2000 return __skb_tx_hash(dev, skb, dev->real_num_tx_queues);
2001 } 2001 }
2002 2002
2003 /** 2003 /**
2004 * netif_is_multiqueue - test if device has multiple transmit queues 2004 * netif_is_multiqueue - test if device has multiple transmit queues
2005 * @dev: network device 2005 * @dev: network device
2006 * 2006 *
2007 * Check if device has multiple transmit queues 2007 * Check if device has multiple transmit queues
2008 */ 2008 */
2009 static inline int netif_is_multiqueue(const struct net_device *dev) 2009 static inline int netif_is_multiqueue(const struct net_device *dev)
2010 { 2010 {
2011 return dev->num_tx_queues > 1; 2011 return dev->num_tx_queues > 1;
2012 } 2012 }
2013 2013
2014 extern int netif_set_real_num_tx_queues(struct net_device *dev, 2014 extern int netif_set_real_num_tx_queues(struct net_device *dev,
2015 unsigned int txq); 2015 unsigned int txq);
2016 2016
2017 #ifdef CONFIG_RPS 2017 #ifdef CONFIG_RPS
2018 extern int netif_set_real_num_rx_queues(struct net_device *dev, 2018 extern int netif_set_real_num_rx_queues(struct net_device *dev,
2019 unsigned int rxq); 2019 unsigned int rxq);
2020 #else 2020 #else
2021 static inline int netif_set_real_num_rx_queues(struct net_device *dev, 2021 static inline int netif_set_real_num_rx_queues(struct net_device *dev,
2022 unsigned int rxq) 2022 unsigned int rxq)
2023 { 2023 {
2024 return 0; 2024 return 0;
2025 } 2025 }
2026 #endif 2026 #endif
2027 2027
2028 static inline int netif_copy_real_num_queues(struct net_device *to_dev, 2028 static inline int netif_copy_real_num_queues(struct net_device *to_dev,
2029 const struct net_device *from_dev) 2029 const struct net_device *from_dev)
2030 { 2030 {
2031 netif_set_real_num_tx_queues(to_dev, from_dev->real_num_tx_queues); 2031 netif_set_real_num_tx_queues(to_dev, from_dev->real_num_tx_queues);
2032 #ifdef CONFIG_RPS 2032 #ifdef CONFIG_RPS
2033 return netif_set_real_num_rx_queues(to_dev, 2033 return netif_set_real_num_rx_queues(to_dev,
2034 from_dev->real_num_rx_queues); 2034 from_dev->real_num_rx_queues);
2035 #else 2035 #else
2036 return 0; 2036 return 0;
2037 #endif 2037 #endif
2038 } 2038 }
2039 2039
2040 /* Use this variant when it is known for sure that it 2040 /* Use this variant when it is known for sure that it
2041 * is executing from hardware interrupt context or with hardware interrupts 2041 * is executing from hardware interrupt context or with hardware interrupts
2042 * disabled. 2042 * disabled.
2043 */ 2043 */
2044 extern void dev_kfree_skb_irq(struct sk_buff *skb); 2044 extern void dev_kfree_skb_irq(struct sk_buff *skb);
2045 2045
2046 /* Use this variant in places where it could be invoked 2046 /* Use this variant in places where it could be invoked
2047 * from either hardware interrupt or other context, with hardware interrupts 2047 * from either hardware interrupt or other context, with hardware interrupts
2048 * either disabled or enabled. 2048 * either disabled or enabled.
2049 */ 2049 */
2050 extern void dev_kfree_skb_any(struct sk_buff *skb); 2050 extern void dev_kfree_skb_any(struct sk_buff *skb);
2051 2051
2052 extern int netif_rx(struct sk_buff *skb); 2052 extern int netif_rx(struct sk_buff *skb);
2053 extern int netif_rx_ni(struct sk_buff *skb); 2053 extern int netif_rx_ni(struct sk_buff *skb);
2054 extern int netif_receive_skb(struct sk_buff *skb); 2054 extern int netif_receive_skb(struct sk_buff *skb);
2055 extern gro_result_t dev_gro_receive(struct napi_struct *napi, 2055 extern gro_result_t dev_gro_receive(struct napi_struct *napi,
2056 struct sk_buff *skb); 2056 struct sk_buff *skb);
2057 extern gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb); 2057 extern gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb);
2058 extern gro_result_t napi_gro_receive(struct napi_struct *napi, 2058 extern gro_result_t napi_gro_receive(struct napi_struct *napi,
2059 struct sk_buff *skb); 2059 struct sk_buff *skb);
2060 extern void napi_gro_flush(struct napi_struct *napi); 2060 extern void napi_gro_flush(struct napi_struct *napi);
2061 extern struct sk_buff * napi_get_frags(struct napi_struct *napi); 2061 extern struct sk_buff * napi_get_frags(struct napi_struct *napi);
2062 extern gro_result_t napi_frags_finish(struct napi_struct *napi, 2062 extern gro_result_t napi_frags_finish(struct napi_struct *napi,
2063 struct sk_buff *skb, 2063 struct sk_buff *skb,
2064 gro_result_t ret); 2064 gro_result_t ret);
2065 extern struct sk_buff * napi_frags_skb(struct napi_struct *napi); 2065 extern struct sk_buff * napi_frags_skb(struct napi_struct *napi);
2066 extern gro_result_t napi_gro_frags(struct napi_struct *napi); 2066 extern gro_result_t napi_gro_frags(struct napi_struct *napi);
2067 2067
2068 static inline void napi_free_frags(struct napi_struct *napi) 2068 static inline void napi_free_frags(struct napi_struct *napi)
2069 { 2069 {
2070 kfree_skb(napi->skb); 2070 kfree_skb(napi->skb);
2071 napi->skb = NULL; 2071 napi->skb = NULL;
2072 } 2072 }
2073 2073
2074 extern int netdev_rx_handler_register(struct net_device *dev, 2074 extern int netdev_rx_handler_register(struct net_device *dev,
2075 rx_handler_func_t *rx_handler, 2075 rx_handler_func_t *rx_handler,
2076 void *rx_handler_data); 2076 void *rx_handler_data);
2077 extern void netdev_rx_handler_unregister(struct net_device *dev); 2077 extern void netdev_rx_handler_unregister(struct net_device *dev);
2078 2078
2079 extern int dev_valid_name(const char *name); 2079 extern int dev_valid_name(const char *name);
2080 extern int dev_ioctl(struct net *net, unsigned int cmd, void __user *); 2080 extern int dev_ioctl(struct net *net, unsigned int cmd, void __user *);
2081 extern int dev_ethtool(struct net *net, struct ifreq *); 2081 extern int dev_ethtool(struct net *net, struct ifreq *);
2082 extern unsigned dev_get_flags(const struct net_device *); 2082 extern unsigned dev_get_flags(const struct net_device *);
2083 extern int __dev_change_flags(struct net_device *, unsigned int flags); 2083 extern int __dev_change_flags(struct net_device *, unsigned int flags);
2084 extern int dev_change_flags(struct net_device *, unsigned); 2084 extern int dev_change_flags(struct net_device *, unsigned);
2085 extern void __dev_notify_flags(struct net_device *, unsigned int old_flags); 2085 extern void __dev_notify_flags(struct net_device *, unsigned int old_flags);
2086 extern int dev_change_name(struct net_device *, const char *); 2086 extern int dev_change_name(struct net_device *, const char *);
2087 extern int dev_set_alias(struct net_device *, const char *, size_t); 2087 extern int dev_set_alias(struct net_device *, const char *, size_t);
2088 extern int dev_change_net_namespace(struct net_device *, 2088 extern int dev_change_net_namespace(struct net_device *,
2089 struct net *, const char *); 2089 struct net *, const char *);
2090 extern int dev_set_mtu(struct net_device *, int); 2090 extern int dev_set_mtu(struct net_device *, int);
2091 extern void dev_set_group(struct net_device *, int); 2091 extern void dev_set_group(struct net_device *, int);
2092 extern int dev_set_mac_address(struct net_device *, 2092 extern int dev_set_mac_address(struct net_device *,
2093 struct sockaddr *); 2093 struct sockaddr *);
2094 extern int dev_hard_start_xmit(struct sk_buff *skb, 2094 extern int dev_hard_start_xmit(struct sk_buff *skb,
2095 struct net_device *dev, 2095 struct net_device *dev,
2096 struct netdev_queue *txq); 2096 struct netdev_queue *txq);
2097 extern int dev_forward_skb(struct net_device *dev, 2097 extern int dev_forward_skb(struct net_device *dev,
2098 struct sk_buff *skb); 2098 struct sk_buff *skb);
2099 2099
2100 extern int netdev_budget; 2100 extern int netdev_budget;
2101 2101
2102 /* Called by rtnetlink.c:rtnl_unlock() */ 2102 /* Called by rtnetlink.c:rtnl_unlock() */
2103 extern void netdev_run_todo(void); 2103 extern void netdev_run_todo(void);
2104 2104
2105 /** 2105 /**
2106 * dev_put - release reference to device 2106 * dev_put - release reference to device
2107 * @dev: network device 2107 * @dev: network device
2108 * 2108 *
2109 * Release reference to device to allow it to be freed. 2109 * Release reference to device to allow it to be freed.
2110 */ 2110 */
2111 static inline void dev_put(struct net_device *dev) 2111 static inline void dev_put(struct net_device *dev)
2112 { 2112 {
2113 irqsafe_cpu_dec(*dev->pcpu_refcnt); 2113 irqsafe_cpu_dec(*dev->pcpu_refcnt);
2114 } 2114 }
2115 2115
2116 /** 2116 /**
2117 * dev_hold - get reference to device 2117 * dev_hold - get reference to device
2118 * @dev: network device 2118 * @dev: network device
2119 * 2119 *
2120 * Hold reference to device to keep it from being freed. 2120 * Hold reference to device to keep it from being freed.
2121 */ 2121 */
2122 static inline void dev_hold(struct net_device *dev) 2122 static inline void dev_hold(struct net_device *dev)
2123 { 2123 {
2124 irqsafe_cpu_inc(*dev->pcpu_refcnt); 2124 irqsafe_cpu_inc(*dev->pcpu_refcnt);
2125 } 2125 }
2126 2126
2127 /* Carrier loss detection, dial on demand. The functions netif_carrier_on 2127 /* Carrier loss detection, dial on demand. The functions netif_carrier_on
2128 * and _off may be called from IRQ context, but it is caller 2128 * and _off may be called from IRQ context, but it is caller
2129 * who is responsible for serialization of these calls. 2129 * who is responsible for serialization of these calls.
2130 * 2130 *
2131 * The name carrier is inappropriate, these functions should really be 2131 * The name carrier is inappropriate, these functions should really be
2132 * called netif_lowerlayer_*() because they represent the state of any 2132 * called netif_lowerlayer_*() because they represent the state of any
2133 * kind of lower layer not just hardware media. 2133 * kind of lower layer not just hardware media.
2134 */ 2134 */
2135 2135
2136 extern void linkwatch_fire_event(struct net_device *dev); 2136 extern void linkwatch_fire_event(struct net_device *dev);
2137 extern void linkwatch_forget_dev(struct net_device *dev); 2137 extern void linkwatch_forget_dev(struct net_device *dev);
2138 2138
2139 /** 2139 /**
2140 * netif_carrier_ok - test if carrier present 2140 * netif_carrier_ok - test if carrier present
2141 * @dev: network device 2141 * @dev: network device
2142 * 2142 *
2143 * Check if carrier is present on device 2143 * Check if carrier is present on device
2144 */ 2144 */
2145 static inline int netif_carrier_ok(const struct net_device *dev) 2145 static inline int netif_carrier_ok(const struct net_device *dev)
2146 { 2146 {
2147 return !test_bit(__LINK_STATE_NOCARRIER, &dev->state); 2147 return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
2148 } 2148 }
2149 2149
2150 extern unsigned long dev_trans_start(struct net_device *dev); 2150 extern unsigned long dev_trans_start(struct net_device *dev);
2151 2151
2152 extern void __netdev_watchdog_up(struct net_device *dev); 2152 extern void __netdev_watchdog_up(struct net_device *dev);
2153 2153
2154 extern void netif_carrier_on(struct net_device *dev); 2154 extern void netif_carrier_on(struct net_device *dev);
2155 2155
2156 extern void netif_carrier_off(struct net_device *dev); 2156 extern void netif_carrier_off(struct net_device *dev);
2157 2157
2158 extern void netif_notify_peers(struct net_device *dev); 2158 extern void netif_notify_peers(struct net_device *dev);
2159 2159
2160 /** 2160 /**
2161 * netif_dormant_on - mark device as dormant. 2161 * netif_dormant_on - mark device as dormant.
2162 * @dev: network device 2162 * @dev: network device
2163 * 2163 *
2164 * Mark device as dormant (as per RFC2863). 2164 * Mark device as dormant (as per RFC2863).
2165 * 2165 *
2166 * The dormant state indicates that the relevant interface is not 2166 * The dormant state indicates that the relevant interface is not
2167 * actually in a condition to pass packets (i.e., it is not 'up') but is 2167 * actually in a condition to pass packets (i.e., it is not 'up') but is
2168 * in a "pending" state, waiting for some external event. For "on- 2168 * in a "pending" state, waiting for some external event. For "on-
2169 * demand" interfaces, this new state identifies the situation where the 2169 * demand" interfaces, this new state identifies the situation where the
2170 * interface is waiting for events to place it in the up state. 2170 * interface is waiting for events to place it in the up state.
2171 * 2171 *
2172 */ 2172 */
2173 static inline void netif_dormant_on(struct net_device *dev) 2173 static inline void netif_dormant_on(struct net_device *dev)
2174 { 2174 {
2175 if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state)) 2175 if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
2176 linkwatch_fire_event(dev); 2176 linkwatch_fire_event(dev);
2177 } 2177 }
2178 2178
2179 /** 2179 /**
2180 * netif_dormant_off - set device as not dormant. 2180 * netif_dormant_off - set device as not dormant.
2181 * @dev: network device 2181 * @dev: network device
2182 * 2182 *
2183 * Device is not in dormant state. 2183 * Device is not in dormant state.
2184 */ 2184 */
2185 static inline void netif_dormant_off(struct net_device *dev) 2185 static inline void netif_dormant_off(struct net_device *dev)
2186 { 2186 {
2187 if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state)) 2187 if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
2188 linkwatch_fire_event(dev); 2188 linkwatch_fire_event(dev);
2189 } 2189 }
2190 2190
2191 /** 2191 /**
2192 * netif_dormant - test if carrier present 2192 * netif_dormant - test if carrier present
2193 * @dev: network device 2193 * @dev: network device
2194 * 2194 *
2195 * Check if carrier is present on device 2195 * Check if carrier is present on device
2196 */ 2196 */
2197 static inline int netif_dormant(const struct net_device *dev) 2197 static inline int netif_dormant(const struct net_device *dev)
2198 { 2198 {
2199 return test_bit(__LINK_STATE_DORMANT, &dev->state); 2199 return test_bit(__LINK_STATE_DORMANT, &dev->state);
2200 } 2200 }
2201 2201
2202 2202
2203 /** 2203 /**
2204 * netif_oper_up - test if device is operational 2204 * netif_oper_up - test if device is operational
2205 * @dev: network device 2205 * @dev: network device
2206 * 2206 *
2207 * Check if carrier is operational 2207 * Check if carrier is operational
2208 */ 2208 */
2209 static inline int netif_oper_up(const struct net_device *dev) 2209 static inline int netif_oper_up(const struct net_device *dev)
2210 { 2210 {
2211 return (dev->operstate == IF_OPER_UP || 2211 return (dev->operstate == IF_OPER_UP ||
2212 dev->operstate == IF_OPER_UNKNOWN /* backward compat */); 2212 dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
2213 } 2213 }
2214 2214
2215 /** 2215 /**
2216 * netif_device_present - is device available or removed 2216 * netif_device_present - is device available or removed
2217 * @dev: network device 2217 * @dev: network device
2218 * 2218 *
2219 * Check if device has not been removed from system. 2219 * Check if device has not been removed from system.
2220 */ 2220 */
2221 static inline int netif_device_present(struct net_device *dev) 2221 static inline int netif_device_present(struct net_device *dev)
2222 { 2222 {
2223 return test_bit(__LINK_STATE_PRESENT, &dev->state); 2223 return test_bit(__LINK_STATE_PRESENT, &dev->state);
2224 } 2224 }
2225 2225
2226 extern void netif_device_detach(struct net_device *dev); 2226 extern void netif_device_detach(struct net_device *dev);
2227 2227
2228 extern void netif_device_attach(struct net_device *dev); 2228 extern void netif_device_attach(struct net_device *dev);
2229 2229
2230 /* 2230 /*
2231 * Network interface message level settings 2231 * Network interface message level settings
2232 */ 2232 */
2233 2233
2234 enum { 2234 enum {
2235 NETIF_MSG_DRV = 0x0001, 2235 NETIF_MSG_DRV = 0x0001,
2236 NETIF_MSG_PROBE = 0x0002, 2236 NETIF_MSG_PROBE = 0x0002,
2237 NETIF_MSG_LINK = 0x0004, 2237 NETIF_MSG_LINK = 0x0004,
2238 NETIF_MSG_TIMER = 0x0008, 2238 NETIF_MSG_TIMER = 0x0008,
2239 NETIF_MSG_IFDOWN = 0x0010, 2239 NETIF_MSG_IFDOWN = 0x0010,
2240 NETIF_MSG_IFUP = 0x0020, 2240 NETIF_MSG_IFUP = 0x0020,
2241 NETIF_MSG_RX_ERR = 0x0040, 2241 NETIF_MSG_RX_ERR = 0x0040,
2242 NETIF_MSG_TX_ERR = 0x0080, 2242 NETIF_MSG_TX_ERR = 0x0080,
2243 NETIF_MSG_TX_QUEUED = 0x0100, 2243 NETIF_MSG_TX_QUEUED = 0x0100,
2244 NETIF_MSG_INTR = 0x0200, 2244 NETIF_MSG_INTR = 0x0200,
2245 NETIF_MSG_TX_DONE = 0x0400, 2245 NETIF_MSG_TX_DONE = 0x0400,
2246 NETIF_MSG_RX_STATUS = 0x0800, 2246 NETIF_MSG_RX_STATUS = 0x0800,
2247 NETIF_MSG_PKTDATA = 0x1000, 2247 NETIF_MSG_PKTDATA = 0x1000,
2248 NETIF_MSG_HW = 0x2000, 2248 NETIF_MSG_HW = 0x2000,
2249 NETIF_MSG_WOL = 0x4000, 2249 NETIF_MSG_WOL = 0x4000,
2250 }; 2250 };
2251 2251
2252 #define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV) 2252 #define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)
2253 #define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE) 2253 #define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)
2254 #define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK) 2254 #define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)
2255 #define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER) 2255 #define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)
2256 #define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN) 2256 #define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)
2257 #define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP) 2257 #define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)
2258 #define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR) 2258 #define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)
2259 #define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR) 2259 #define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)
2260 #define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED) 2260 #define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
2261 #define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR) 2261 #define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)
2262 #define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE) 2262 #define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)
2263 #define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS) 2263 #define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)
2264 #define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA) 2264 #define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)
2265 #define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW) 2265 #define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)
2266 #define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL) 2266 #define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)
2267 2267
2268 static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits) 2268 static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
2269 { 2269 {
2270 /* use default */ 2270 /* use default */
2271 if (debug_value < 0 || debug_value >= (sizeof(u32) * 8)) 2271 if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
2272 return default_msg_enable_bits; 2272 return default_msg_enable_bits;
2273 if (debug_value == 0) /* no output */ 2273 if (debug_value == 0) /* no output */
2274 return 0; 2274 return 0;
2275 /* set low N bits */ 2275 /* set low N bits */
2276 return (1 << debug_value) - 1; 2276 return (1 << debug_value) - 1;
2277 } 2277 }
2278 2278
2279 static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu) 2279 static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
2280 { 2280 {
2281 spin_lock(&txq->_xmit_lock); 2281 spin_lock(&txq->_xmit_lock);
2282 txq->xmit_lock_owner = cpu; 2282 txq->xmit_lock_owner = cpu;
2283 } 2283 }
2284 2284
2285 static inline void __netif_tx_lock_bh(struct netdev_queue *txq) 2285 static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
2286 { 2286 {
2287 spin_lock_bh(&txq->_xmit_lock); 2287 spin_lock_bh(&txq->_xmit_lock);
2288 txq->xmit_lock_owner = smp_processor_id(); 2288 txq->xmit_lock_owner = smp_processor_id();
2289 } 2289 }
2290 2290
2291 static inline int __netif_tx_trylock(struct netdev_queue *txq) 2291 static inline int __netif_tx_trylock(struct netdev_queue *txq)
2292 { 2292 {
2293 int ok = spin_trylock(&txq->_xmit_lock); 2293 int ok = spin_trylock(&txq->_xmit_lock);
2294 if (likely(ok)) 2294 if (likely(ok))
2295 txq->xmit_lock_owner = smp_processor_id(); 2295 txq->xmit_lock_owner = smp_processor_id();
2296 return ok; 2296 return ok;
2297 } 2297 }
2298 2298
2299 static inline void __netif_tx_unlock(struct netdev_queue *txq) 2299 static inline void __netif_tx_unlock(struct netdev_queue *txq)
2300 { 2300 {
2301 txq->xmit_lock_owner = -1; 2301 txq->xmit_lock_owner = -1;
2302 spin_unlock(&txq->_xmit_lock); 2302 spin_unlock(&txq->_xmit_lock);
2303 } 2303 }
2304 2304
2305 static inline void __netif_tx_unlock_bh(struct netdev_queue *txq) 2305 static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
2306 { 2306 {
2307 txq->xmit_lock_owner = -1; 2307 txq->xmit_lock_owner = -1;
2308 spin_unlock_bh(&txq->_xmit_lock); 2308 spin_unlock_bh(&txq->_xmit_lock);
2309 } 2309 }
2310 2310
2311 static inline void txq_trans_update(struct netdev_queue *txq) 2311 static inline void txq_trans_update(struct netdev_queue *txq)
2312 { 2312 {
2313 if (txq->xmit_lock_owner != -1) 2313 if (txq->xmit_lock_owner != -1)
2314 txq->trans_start = jiffies; 2314 txq->trans_start = jiffies;
2315 } 2315 }
2316 2316
2317 /** 2317 /**
2318 * netif_tx_lock - grab network device transmit lock 2318 * netif_tx_lock - grab network device transmit lock
2319 * @dev: network device 2319 * @dev: network device
2320 * 2320 *
2321 * Get network device transmit lock 2321 * Get network device transmit lock
2322 */ 2322 */
2323 static inline void netif_tx_lock(struct net_device *dev) 2323 static inline void netif_tx_lock(struct net_device *dev)
2324 { 2324 {
2325 unsigned int i; 2325 unsigned int i;
2326 int cpu; 2326 int cpu;
2327 2327
2328 spin_lock(&dev->tx_global_lock); 2328 spin_lock(&dev->tx_global_lock);
2329 cpu = smp_processor_id(); 2329 cpu = smp_processor_id();
2330 for (i = 0; i < dev->num_tx_queues; i++) { 2330 for (i = 0; i < dev->num_tx_queues; i++) {
2331 struct netdev_queue *txq = netdev_get_tx_queue(dev, i); 2331 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
2332 2332
2333 /* We are the only thread of execution doing a 2333 /* We are the only thread of execution doing a
2334 * freeze, but we have to grab the _xmit_lock in 2334 * freeze, but we have to grab the _xmit_lock in
2335 * order to synchronize with threads which are in 2335 * order to synchronize with threads which are in
2336 * the ->hard_start_xmit() handler and already 2336 * the ->hard_start_xmit() handler and already
2337 * checked the frozen bit. 2337 * checked the frozen bit.
2338 */ 2338 */
2339 __netif_tx_lock(txq, cpu); 2339 __netif_tx_lock(txq, cpu);
2340 set_bit(__QUEUE_STATE_FROZEN, &txq->state); 2340 set_bit(__QUEUE_STATE_FROZEN, &txq->state);
2341 __netif_tx_unlock(txq); 2341 __netif_tx_unlock(txq);
2342 } 2342 }
2343 } 2343 }
2344 2344
2345 static inline void netif_tx_lock_bh(struct net_device *dev) 2345 static inline void netif_tx_lock_bh(struct net_device *dev)
2346 { 2346 {
2347 local_bh_disable(); 2347 local_bh_disable();
2348 netif_tx_lock(dev); 2348 netif_tx_lock(dev);
2349 } 2349 }
2350 2350
2351 static inline void netif_tx_unlock(struct net_device *dev) 2351 static inline void netif_tx_unlock(struct net_device *dev)
2352 { 2352 {
2353 unsigned int i; 2353 unsigned int i;
2354 2354
2355 for (i = 0; i < dev->num_tx_queues; i++) { 2355 for (i = 0; i < dev->num_tx_queues; i++) {
2356 struct netdev_queue *txq = netdev_get_tx_queue(dev, i); 2356 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
2357 2357
2358 /* No need to grab the _xmit_lock here. If the 2358 /* No need to grab the _xmit_lock here. If the
2359 * queue is not stopped for another reason, we 2359 * queue is not stopped for another reason, we
2360 * force a schedule. 2360 * force a schedule.
2361 */ 2361 */
2362 clear_bit(__QUEUE_STATE_FROZEN, &txq->state); 2362 clear_bit(__QUEUE_STATE_FROZEN, &txq->state);
2363 netif_schedule_queue(txq); 2363 netif_schedule_queue(txq);
2364 } 2364 }
2365 spin_unlock(&dev->tx_global_lock); 2365 spin_unlock(&dev->tx_global_lock);
2366 } 2366 }
2367 2367
2368 static inline void netif_tx_unlock_bh(struct net_device *dev) 2368 static inline void netif_tx_unlock_bh(struct net_device *dev)
2369 { 2369 {
2370 netif_tx_unlock(dev); 2370 netif_tx_unlock(dev);
2371 local_bh_enable(); 2371 local_bh_enable();
2372 } 2372 }
2373 2373
2374 #define HARD_TX_LOCK(dev, txq, cpu) { \ 2374 #define HARD_TX_LOCK(dev, txq, cpu) { \
2375 if ((dev->features & NETIF_F_LLTX) == 0) { \ 2375 if ((dev->features & NETIF_F_LLTX) == 0) { \
2376 __netif_tx_lock(txq, cpu); \ 2376 __netif_tx_lock(txq, cpu); \
2377 } \ 2377 } \
2378 } 2378 }
2379 2379
2380 #define HARD_TX_UNLOCK(dev, txq) { \ 2380 #define HARD_TX_UNLOCK(dev, txq) { \
2381 if ((dev->features & NETIF_F_LLTX) == 0) { \ 2381 if ((dev->features & NETIF_F_LLTX) == 0) { \
2382 __netif_tx_unlock(txq); \ 2382 __netif_tx_unlock(txq); \
2383 } \ 2383 } \
2384 } 2384 }
2385 2385
2386 static inline void netif_tx_disable(struct net_device *dev) 2386 static inline void netif_tx_disable(struct net_device *dev)
2387 { 2387 {
2388 unsigned int i; 2388 unsigned int i;
2389 int cpu; 2389 int cpu;
2390 2390
2391 local_bh_disable(); 2391 local_bh_disable();
2392 cpu = smp_processor_id(); 2392 cpu = smp_processor_id();
2393 for (i = 0; i < dev->num_tx_queues; i++) { 2393 for (i = 0; i < dev->num_tx_queues; i++) {
2394 struct netdev_queue *txq = netdev_get_tx_queue(dev, i); 2394 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
2395 2395
2396 __netif_tx_lock(txq, cpu); 2396 __netif_tx_lock(txq, cpu);
2397 netif_tx_stop_queue(txq); 2397 netif_tx_stop_queue(txq);
2398 __netif_tx_unlock(txq); 2398 __netif_tx_unlock(txq);
2399 } 2399 }
2400 local_bh_enable(); 2400 local_bh_enable();
2401 } 2401 }
2402 2402
2403 static inline void netif_addr_lock(struct net_device *dev) 2403 static inline void netif_addr_lock(struct net_device *dev)
2404 { 2404 {
2405 spin_lock(&dev->addr_list_lock); 2405 spin_lock(&dev->addr_list_lock);
2406 } 2406 }
2407 2407
2408 static inline void netif_addr_lock_bh(struct net_device *dev) 2408 static inline void netif_addr_lock_bh(struct net_device *dev)
2409 { 2409 {
2410 spin_lock_bh(&dev->addr_list_lock); 2410 spin_lock_bh(&dev->addr_list_lock);
2411 } 2411 }
2412 2412
2413 static inline void netif_addr_unlock(struct net_device *dev) 2413 static inline void netif_addr_unlock(struct net_device *dev)
2414 { 2414 {
2415 spin_unlock(&dev->addr_list_lock); 2415 spin_unlock(&dev->addr_list_lock);
2416 } 2416 }
2417 2417
2418 static inline void netif_addr_unlock_bh(struct net_device *dev) 2418 static inline void netif_addr_unlock_bh(struct net_device *dev)
2419 { 2419 {
2420 spin_unlock_bh(&dev->addr_list_lock); 2420 spin_unlock_bh(&dev->addr_list_lock);
2421 } 2421 }
2422 2422
2423 /* 2423 /*
2424 * dev_addrs walker. Should be used only for read access. Call with 2424 * dev_addrs walker. Should be used only for read access. Call with
2425 * rcu_read_lock held. 2425 * rcu_read_lock held.
2426 */ 2426 */
2427 #define for_each_dev_addr(dev, ha) \ 2427 #define for_each_dev_addr(dev, ha) \
2428 list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list) 2428 list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
2429 2429
2430 /* These functions live elsewhere (drivers/net/net_init.c, but related) */ 2430 /* These functions live elsewhere (drivers/net/net_init.c, but related) */
2431 2431
2432 extern void ether_setup(struct net_device *dev); 2432 extern void ether_setup(struct net_device *dev);
2433 2433
2434 /* Support for loadable net-drivers */ 2434 /* Support for loadable net-drivers */
2435 extern struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name, 2435 extern struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
2436 void (*setup)(struct net_device *), 2436 void (*setup)(struct net_device *),
2437 unsigned int txqs, unsigned int rxqs); 2437 unsigned int txqs, unsigned int rxqs);
2438 #define alloc_netdev(sizeof_priv, name, setup) \ 2438 #define alloc_netdev(sizeof_priv, name, setup) \
2439 alloc_netdev_mqs(sizeof_priv, name, setup, 1, 1) 2439 alloc_netdev_mqs(sizeof_priv, name, setup, 1, 1)
2440 2440
2441 #define alloc_netdev_mq(sizeof_priv, name, setup, count) \ 2441 #define alloc_netdev_mq(sizeof_priv, name, setup, count) \
2442 alloc_netdev_mqs(sizeof_priv, name, setup, count, count) 2442 alloc_netdev_mqs(sizeof_priv, name, setup, count, count)
2443 2443
2444 extern int register_netdev(struct net_device *dev); 2444 extern int register_netdev(struct net_device *dev);
2445 extern void unregister_netdev(struct net_device *dev); 2445 extern void unregister_netdev(struct net_device *dev);
2446 2446
2447 /* General hardware address lists handling functions */ 2447 /* General hardware address lists handling functions */
2448 extern int __hw_addr_add_multiple(struct netdev_hw_addr_list *to_list, 2448 extern int __hw_addr_add_multiple(struct netdev_hw_addr_list *to_list,
2449 struct netdev_hw_addr_list *from_list, 2449 struct netdev_hw_addr_list *from_list,
2450 int addr_len, unsigned char addr_type); 2450 int addr_len, unsigned char addr_type);
2451 extern void __hw_addr_del_multiple(struct netdev_hw_addr_list *to_list, 2451 extern void __hw_addr_del_multiple(struct netdev_hw_addr_list *to_list,
2452 struct netdev_hw_addr_list *from_list, 2452 struct netdev_hw_addr_list *from_list,
2453 int addr_len, unsigned char addr_type); 2453 int addr_len, unsigned char addr_type);
2454 extern int __hw_addr_sync(struct netdev_hw_addr_list *to_list, 2454 extern int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
2455 struct netdev_hw_addr_list *from_list, 2455 struct netdev_hw_addr_list *from_list,
2456 int addr_len); 2456 int addr_len);
2457 extern void __hw_addr_unsync(struct netdev_hw_addr_list *to_list, 2457 extern void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
2458 struct netdev_hw_addr_list *from_list, 2458 struct netdev_hw_addr_list *from_list,
2459 int addr_len); 2459 int addr_len);
2460 extern void __hw_addr_flush(struct netdev_hw_addr_list *list); 2460 extern void __hw_addr_flush(struct netdev_hw_addr_list *list);
2461 extern void __hw_addr_init(struct netdev_hw_addr_list *list); 2461 extern void __hw_addr_init(struct netdev_hw_addr_list *list);
2462 2462
2463 /* Functions used for device addresses handling */ 2463 /* Functions used for device addresses handling */
2464 extern int dev_addr_add(struct net_device *dev, unsigned char *addr, 2464 extern int dev_addr_add(struct net_device *dev, unsigned char *addr,
2465 unsigned char addr_type); 2465 unsigned char addr_type);
2466 extern int dev_addr_del(struct net_device *dev, unsigned char *addr, 2466 extern int dev_addr_del(struct net_device *dev, unsigned char *addr,
2467 unsigned char addr_type); 2467 unsigned char addr_type);
2468 extern int dev_addr_add_multiple(struct net_device *to_dev, 2468 extern int dev_addr_add_multiple(struct net_device *to_dev,
2469 struct net_device *from_dev, 2469 struct net_device *from_dev,
2470 unsigned char addr_type); 2470 unsigned char addr_type);
2471 extern int dev_addr_del_multiple(struct net_device *to_dev, 2471 extern int dev_addr_del_multiple(struct net_device *to_dev,
2472 struct net_device *from_dev, 2472 struct net_device *from_dev,
2473 unsigned char addr_type); 2473 unsigned char addr_type);
2474 extern void dev_addr_flush(struct net_device *dev); 2474 extern void dev_addr_flush(struct net_device *dev);
2475 extern int dev_addr_init(struct net_device *dev); 2475 extern int dev_addr_init(struct net_device *dev);
2476 2476
2477 /* Functions used for unicast addresses handling */ 2477 /* Functions used for unicast addresses handling */
2478 extern int dev_uc_add(struct net_device *dev, unsigned char *addr); 2478 extern int dev_uc_add(struct net_device *dev, unsigned char *addr);
2479 extern int dev_uc_del(struct net_device *dev, unsigned char *addr); 2479 extern int dev_uc_del(struct net_device *dev, unsigned char *addr);
2480 extern int dev_uc_sync(struct net_device *to, struct net_device *from); 2480 extern int dev_uc_sync(struct net_device *to, struct net_device *from);
2481 extern void dev_uc_unsync(struct net_device *to, struct net_device *from); 2481 extern void dev_uc_unsync(struct net_device *to, struct net_device *from);
2482 extern void dev_uc_flush(struct net_device *dev); 2482 extern void dev_uc_flush(struct net_device *dev);
2483 extern void dev_uc_init(struct net_device *dev); 2483 extern void dev_uc_init(struct net_device *dev);
2484 2484
2485 /* Functions used for multicast addresses handling */ 2485 /* Functions used for multicast addresses handling */
2486 extern int dev_mc_add(struct net_device *dev, unsigned char *addr); 2486 extern int dev_mc_add(struct net_device *dev, unsigned char *addr);
2487 extern int dev_mc_add_global(struct net_device *dev, unsigned char *addr); 2487 extern int dev_mc_add_global(struct net_device *dev, unsigned char *addr);
2488 extern int dev_mc_del(struct net_device *dev, unsigned char *addr); 2488 extern int dev_mc_del(struct net_device *dev, unsigned char *addr);
2489 extern int dev_mc_del_global(struct net_device *dev, unsigned char *addr); 2489 extern int dev_mc_del_global(struct net_device *dev, unsigned char *addr);
2490 extern int dev_mc_sync(struct net_device *to, struct net_device *from); 2490 extern int dev_mc_sync(struct net_device *to, struct net_device *from);
2491 extern void dev_mc_unsync(struct net_device *to, struct net_device *from); 2491 extern void dev_mc_unsync(struct net_device *to, struct net_device *from);
2492 extern void dev_mc_flush(struct net_device *dev); 2492 extern void dev_mc_flush(struct net_device *dev);
2493 extern void dev_mc_init(struct net_device *dev); 2493 extern void dev_mc_init(struct net_device *dev);
2494 2494
2495 /* Functions used for secondary unicast and multicast support */ 2495 /* Functions used for secondary unicast and multicast support */
2496 extern void dev_set_rx_mode(struct net_device *dev); 2496 extern void dev_set_rx_mode(struct net_device *dev);
2497 extern void __dev_set_rx_mode(struct net_device *dev); 2497 extern void __dev_set_rx_mode(struct net_device *dev);
2498 extern int dev_set_promiscuity(struct net_device *dev, int inc); 2498 extern int dev_set_promiscuity(struct net_device *dev, int inc);
2499 extern int dev_set_allmulti(struct net_device *dev, int inc); 2499 extern int dev_set_allmulti(struct net_device *dev, int inc);
2500 extern void netdev_state_change(struct net_device *dev); 2500 extern void netdev_state_change(struct net_device *dev);
2501 extern int netdev_bonding_change(struct net_device *dev, 2501 extern int netdev_bonding_change(struct net_device *dev,
2502 unsigned long event); 2502 unsigned long event);
2503 extern void netdev_features_change(struct net_device *dev); 2503 extern void netdev_features_change(struct net_device *dev);
2504 /* Load a device via the kmod */ 2504 /* Load a device via the kmod */
2505 extern void dev_load(struct net *net, const char *name); 2505 extern void dev_load(struct net *net, const char *name);
2506 extern void dev_mcast_init(void); 2506 extern void dev_mcast_init(void);
2507 extern struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev, 2507 extern struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
2508 struct rtnl_link_stats64 *storage); 2508 struct rtnl_link_stats64 *storage);
2509 2509
2510 extern int netdev_max_backlog; 2510 extern int netdev_max_backlog;
2511 extern int netdev_tstamp_prequeue; 2511 extern int netdev_tstamp_prequeue;
2512 extern int weight_p; 2512 extern int weight_p;
2513 extern int bpf_jit_enable; 2513 extern int bpf_jit_enable;
2514 extern int netdev_set_master(struct net_device *dev, struct net_device *master); 2514 extern int netdev_set_master(struct net_device *dev, struct net_device *master);
2515 extern int netdev_set_bond_master(struct net_device *dev, 2515 extern int netdev_set_bond_master(struct net_device *dev,
2516 struct net_device *master); 2516 struct net_device *master);
2517 extern int skb_checksum_help(struct sk_buff *skb); 2517 extern int skb_checksum_help(struct sk_buff *skb);
2518 extern struct sk_buff *skb_gso_segment(struct sk_buff *skb, u32 features); 2518 extern struct sk_buff *skb_gso_segment(struct sk_buff *skb, u32 features);
2519 #ifdef CONFIG_BUG 2519 #ifdef CONFIG_BUG
2520 extern void netdev_rx_csum_fault(struct net_device *dev); 2520 extern void netdev_rx_csum_fault(struct net_device *dev);
2521 #else 2521 #else
2522 static inline void netdev_rx_csum_fault(struct net_device *dev) 2522 static inline void netdev_rx_csum_fault(struct net_device *dev)
2523 { 2523 {
2524 } 2524 }
2525 #endif 2525 #endif
2526 /* rx skb timestamps */ 2526 /* rx skb timestamps */
2527 extern void net_enable_timestamp(void); 2527 extern void net_enable_timestamp(void);
2528 extern void net_disable_timestamp(void); 2528 extern void net_disable_timestamp(void);
2529 2529
2530 #ifdef CONFIG_PROC_FS 2530 #ifdef CONFIG_PROC_FS
2531 extern void *dev_seq_start(struct seq_file *seq, loff_t *pos); 2531 extern void *dev_seq_start(struct seq_file *seq, loff_t *pos);
2532 extern void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos); 2532 extern void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos);
2533 extern void dev_seq_stop(struct seq_file *seq, void *v); 2533 extern void dev_seq_stop(struct seq_file *seq, void *v);
2534 #endif 2534 #endif
2535 2535
2536 extern int netdev_class_create_file(struct class_attribute *class_attr); 2536 extern int netdev_class_create_file(struct class_attribute *class_attr);
2537 extern void netdev_class_remove_file(struct class_attribute *class_attr); 2537 extern void netdev_class_remove_file(struct class_attribute *class_attr);
2538 2538
2539 extern struct kobj_ns_type_operations net_ns_type_operations; 2539 extern struct kobj_ns_type_operations net_ns_type_operations;
2540 2540
2541 extern const char *netdev_drivername(const struct net_device *dev); 2541 extern const char *netdev_drivername(const struct net_device *dev);
2542 2542
2543 extern void linkwatch_run_queue(void); 2543 extern void linkwatch_run_queue(void);
2544 2544
2545 static inline u32 netdev_get_wanted_features(struct net_device *dev) 2545 static inline u32 netdev_get_wanted_features(struct net_device *dev)
2546 { 2546 {
2547 return (dev->features & ~dev->hw_features) | dev->wanted_features; 2547 return (dev->features & ~dev->hw_features) | dev->wanted_features;
2548 } 2548 }
2549 u32 netdev_increment_features(u32 all, u32 one, u32 mask); 2549 u32 netdev_increment_features(u32 all, u32 one, u32 mask);
2550 int __netdev_update_features(struct net_device *dev); 2550 int __netdev_update_features(struct net_device *dev);
2551 void netdev_update_features(struct net_device *dev); 2551 void netdev_update_features(struct net_device *dev);
2552 void netdev_change_features(struct net_device *dev); 2552 void netdev_change_features(struct net_device *dev);
2553 2553
2554 void netif_stacked_transfer_operstate(const struct net_device *rootdev, 2554 void netif_stacked_transfer_operstate(const struct net_device *rootdev,
2555 struct net_device *dev); 2555 struct net_device *dev);
2556 2556
2557 u32 netif_skb_features(struct sk_buff *skb); 2557 u32 netif_skb_features(struct sk_buff *skb);
2558 2558
2559 static inline int net_gso_ok(u32 features, int gso_type) 2559 static inline int net_gso_ok(u32 features, int gso_type)
2560 { 2560 {
2561 int feature = gso_type << NETIF_F_GSO_SHIFT; 2561 int feature = gso_type << NETIF_F_GSO_SHIFT;
2562 return (features & feature) == feature; 2562 return (features & feature) == feature;
2563 } 2563 }
2564 2564
2565 static inline int skb_gso_ok(struct sk_buff *skb, u32 features) 2565 static inline int skb_gso_ok(struct sk_buff *skb, u32 features)
2566 { 2566 {
2567 return net_gso_ok(features, skb_shinfo(skb)->gso_type) && 2567 return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
2568 (!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST)); 2568 (!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST));
2569 } 2569 }
2570 2570
2571 static inline int netif_needs_gso(struct sk_buff *skb, int features) 2571 static inline int netif_needs_gso(struct sk_buff *skb, int features)
2572 { 2572 {
2573 return skb_is_gso(skb) && (!skb_gso_ok(skb, features) || 2573 return skb_is_gso(skb) && (!skb_gso_ok(skb, features) ||
2574 unlikely(skb->ip_summed != CHECKSUM_PARTIAL)); 2574 unlikely(skb->ip_summed != CHECKSUM_PARTIAL));
2575 } 2575 }
2576 2576
2577 static inline void netif_set_gso_max_size(struct net_device *dev, 2577 static inline void netif_set_gso_max_size(struct net_device *dev,
2578 unsigned int size) 2578 unsigned int size)
2579 { 2579 {
2580 dev->gso_max_size = size; 2580 dev->gso_max_size = size;
2581 } 2581 }
2582 2582
2583 static inline int netif_is_bond_slave(struct net_device *dev) 2583 static inline int netif_is_bond_slave(struct net_device *dev)
2584 { 2584 {
2585 return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING; 2585 return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING;
2586 } 2586 }
2587 2587
2588 extern struct pernet_operations __net_initdata loopback_net_ops; 2588 extern struct pernet_operations __net_initdata loopback_net_ops;
2589 2589
2590 int dev_ethtool_get_settings(struct net_device *dev, 2590 int dev_ethtool_get_settings(struct net_device *dev,
2591 struct ethtool_cmd *cmd); 2591 struct ethtool_cmd *cmd);
2592 2592
2593 static inline u32 dev_ethtool_get_rx_csum(struct net_device *dev) 2593 static inline u32 dev_ethtool_get_rx_csum(struct net_device *dev)
2594 { 2594 {
2595 if (dev->features & NETIF_F_RXCSUM) 2595 if (dev->features & NETIF_F_RXCSUM)
2596 return 1; 2596 return 1;
2597 if (!dev->ethtool_ops || !dev->ethtool_ops->get_rx_csum) 2597 if (!dev->ethtool_ops || !dev->ethtool_ops->get_rx_csum)
2598 return 0; 2598 return 0;
2599 return dev->ethtool_ops->get_rx_csum(dev); 2599 return dev->ethtool_ops->get_rx_csum(dev);
2600 } 2600 }
2601 2601
2602 static inline u32 dev_ethtool_get_flags(struct net_device *dev) 2602 static inline u32 dev_ethtool_get_flags(struct net_device *dev)
2603 { 2603 {
2604 if (!dev->ethtool_ops || !dev->ethtool_ops->get_flags) 2604 if (!dev->ethtool_ops || !dev->ethtool_ops->get_flags)
2605 return 0; 2605 return 0;
2606 return dev->ethtool_ops->get_flags(dev); 2606 return dev->ethtool_ops->get_flags(dev);
2607 } 2607 }
2608 2608
2609 /* Logging, debugging and troubleshooting/diagnostic helpers. */ 2609 /* Logging, debugging and troubleshooting/diagnostic helpers. */
2610 2610
2611 /* netdev_printk helpers, similar to dev_printk */ 2611 /* netdev_printk helpers, similar to dev_printk */
2612 2612
2613 static inline const char *netdev_name(const struct net_device *dev) 2613 static inline const char *netdev_name(const struct net_device *dev)
2614 { 2614 {
2615 if (dev->reg_state != NETREG_REGISTERED) 2615 if (dev->reg_state != NETREG_REGISTERED)
2616 return "(unregistered net_device)"; 2616 return "(unregistered net_device)";
2617 return dev->name; 2617 return dev->name;
2618 } 2618 }
2619 2619
2620 extern int netdev_printk(const char *level, const struct net_device *dev, 2620 extern int netdev_printk(const char *level, const struct net_device *dev,
2621 const char *format, ...) 2621 const char *format, ...)
2622 __attribute__ ((format (printf, 3, 4))); 2622 __attribute__ ((format (printf, 3, 4)));
2623 extern int netdev_emerg(const struct net_device *dev, const char *format, ...) 2623 extern int netdev_emerg(const struct net_device *dev, const char *format, ...)
2624 __attribute__ ((format (printf, 2, 3))); 2624 __attribute__ ((format (printf, 2, 3)));
2625 extern int netdev_alert(const struct net_device *dev, const char *format, ...) 2625 extern int netdev_alert(const struct net_device *dev, const char *format, ...)
2626 __attribute__ ((format (printf, 2, 3))); 2626 __attribute__ ((format (printf, 2, 3)));
2627 extern int netdev_crit(const struct net_device *dev, const char *format, ...) 2627 extern int netdev_crit(const struct net_device *dev, const char *format, ...)
2628 __attribute__ ((format (printf, 2, 3))); 2628 __attribute__ ((format (printf, 2, 3)));
2629 extern int netdev_err(const struct net_device *dev, const char *format, ...) 2629 extern int netdev_err(const struct net_device *dev, const char *format, ...)
2630 __attribute__ ((format (printf, 2, 3))); 2630 __attribute__ ((format (printf, 2, 3)));
2631 extern int netdev_warn(const struct net_device *dev, const char *format, ...) 2631 extern int netdev_warn(const struct net_device *dev, const char *format, ...)
2632 __attribute__ ((format (printf, 2, 3))); 2632 __attribute__ ((format (printf, 2, 3)));
2633 extern int netdev_notice(const struct net_device *dev, const char *format, ...) 2633 extern int netdev_notice(const struct net_device *dev, const char *format, ...)
2634 __attribute__ ((format (printf, 2, 3))); 2634 __attribute__ ((format (printf, 2, 3)));
2635 extern int netdev_info(const struct net_device *dev, const char *format, ...) 2635 extern int netdev_info(const struct net_device *dev, const char *format, ...)
2636 __attribute__ ((format (printf, 2, 3))); 2636 __attribute__ ((format (printf, 2, 3)));
2637 2637
2638 #define MODULE_ALIAS_NETDEV(device) \ 2638 #define MODULE_ALIAS_NETDEV(device) \
2639 MODULE_ALIAS("netdev-" device) 2639 MODULE_ALIAS("netdev-" device)
2640 2640
2641 #if defined(DEBUG) 2641 #if defined(DEBUG)
2642 #define netdev_dbg(__dev, format, args...) \ 2642 #define netdev_dbg(__dev, format, args...) \
2643 netdev_printk(KERN_DEBUG, __dev, format, ##args) 2643 netdev_printk(KERN_DEBUG, __dev, format, ##args)
2644 #elif defined(CONFIG_DYNAMIC_DEBUG) 2644 #elif defined(CONFIG_DYNAMIC_DEBUG)
2645 #define netdev_dbg(__dev, format, args...) \ 2645 #define netdev_dbg(__dev, format, args...) \
2646 do { \ 2646 do { \
2647 dynamic_dev_dbg((__dev)->dev.parent, "%s: " format, \ 2647 dynamic_dev_dbg((__dev)->dev.parent, "%s: " format, \
2648 netdev_name(__dev), ##args); \ 2648 netdev_name(__dev), ##args); \
2649 } while (0) 2649 } while (0)
2650 #else 2650 #else
2651 #define netdev_dbg(__dev, format, args...) \ 2651 #define netdev_dbg(__dev, format, args...) \
2652 ({ \ 2652 ({ \
2653 if (0) \ 2653 if (0) \
2654 netdev_printk(KERN_DEBUG, __dev, format, ##args); \ 2654 netdev_printk(KERN_DEBUG, __dev, format, ##args); \
2655 0; \ 2655 0; \
2656 }) 2656 })
2657 #endif 2657 #endif
2658 2658
2659 #if defined(VERBOSE_DEBUG) 2659 #if defined(VERBOSE_DEBUG)
2660 #define netdev_vdbg netdev_dbg 2660 #define netdev_vdbg netdev_dbg
2661 #else 2661 #else
2662 2662
2663 #define netdev_vdbg(dev, format, args...) \ 2663 #define netdev_vdbg(dev, format, args...) \
2664 ({ \ 2664 ({ \
2665 if (0) \ 2665 if (0) \
2666 netdev_printk(KERN_DEBUG, dev, format, ##args); \ 2666 netdev_printk(KERN_DEBUG, dev, format, ##args); \
2667 0; \ 2667 0; \
2668 }) 2668 })
2669 #endif 2669 #endif
2670 2670
2671 /* 2671 /*
2672 * netdev_WARN() acts like dev_printk(), but with the key difference 2672 * netdev_WARN() acts like dev_printk(), but with the key difference
2673 * of using a WARN/WARN_ON to get the message out, including the 2673 * of using a WARN/WARN_ON to get the message out, including the
2674 * file/line information and a backtrace. 2674 * file/line information and a backtrace.
2675 */ 2675 */
2676 #define netdev_WARN(dev, format, args...) \ 2676 #define netdev_WARN(dev, format, args...) \
2677 WARN(1, "netdevice: %s\n" format, netdev_name(dev), ##args); 2677 WARN(1, "netdevice: %s\n" format, netdev_name(dev), ##args);
2678 2678
2679 /* netif printk helpers, similar to netdev_printk */ 2679 /* netif printk helpers, similar to netdev_printk */
2680 2680
2681 #define netif_printk(priv, type, level, dev, fmt, args...) \ 2681 #define netif_printk(priv, type, level, dev, fmt, args...) \
2682 do { \ 2682 do { \
2683 if (netif_msg_##type(priv)) \ 2683 if (netif_msg_##type(priv)) \
2684 netdev_printk(level, (dev), fmt, ##args); \ 2684 netdev_printk(level, (dev), fmt, ##args); \
2685 } while (0) 2685 } while (0)
2686 2686
2687 #define netif_level(level, priv, type, dev, fmt, args...) \ 2687 #define netif_level(level, priv, type, dev, fmt, args...) \
2688 do { \ 2688 do { \
2689 if (netif_msg_##type(priv)) \ 2689 if (netif_msg_##type(priv)) \
2690 netdev_##level(dev, fmt, ##args); \ 2690 netdev_##level(dev, fmt, ##args); \
2691 } while (0) 2691 } while (0)
2692 2692
2693 #define netif_emerg(priv, type, dev, fmt, args...) \ 2693 #define netif_emerg(priv, type, dev, fmt, args...) \
2694 netif_level(emerg, priv, type, dev, fmt, ##args) 2694 netif_level(emerg, priv, type, dev, fmt, ##args)
2695 #define netif_alert(priv, type, dev, fmt, args...) \ 2695 #define netif_alert(priv, type, dev, fmt, args...) \
2696 netif_level(alert, priv, type, dev, fmt, ##args) 2696 netif_level(alert, priv, type, dev, fmt, ##args)
2697 #define netif_crit(priv, type, dev, fmt, args...) \ 2697 #define netif_crit(priv, type, dev, fmt, args...) \
2698 netif_level(crit, priv, type, dev, fmt, ##args) 2698 netif_level(crit, priv, type, dev, fmt, ##args)
2699 #define netif_err(priv, type, dev, fmt, args...) \ 2699 #define netif_err(priv, type, dev, fmt, args...) \
2700 netif_level(err, priv, type, dev, fmt, ##args) 2700 netif_level(err, priv, type, dev, fmt, ##args)
2701 #define netif_warn(priv, type, dev, fmt, args...) \ 2701 #define netif_warn(priv, type, dev, fmt, args...) \
2702 netif_level(warn, priv, type, dev, fmt, ##args) 2702 netif_level(warn, priv, type, dev, fmt, ##args)
2703 #define netif_notice(priv, type, dev, fmt, args...) \ 2703 #define netif_notice(priv, type, dev, fmt, args...) \
2704 netif_level(notice, priv, type, dev, fmt, ##args) 2704 netif_level(notice, priv, type, dev, fmt, ##args)
2705 #define netif_info(priv, type, dev, fmt, args...) \ 2705 #define netif_info(priv, type, dev, fmt, args...) \
2706 netif_level(info, priv, type, dev, fmt, ##args) 2706 netif_level(info, priv, type, dev, fmt, ##args)
2707 2707
2708 #if defined(DEBUG) 2708 #if defined(DEBUG)
2709 #define netif_dbg(priv, type, dev, format, args...) \ 2709 #define netif_dbg(priv, type, dev, format, args...) \
2710 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args) 2710 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args)
2711 #elif defined(CONFIG_DYNAMIC_DEBUG) 2711 #elif defined(CONFIG_DYNAMIC_DEBUG)
2712 #define netif_dbg(priv, type, netdev, format, args...) \ 2712 #define netif_dbg(priv, type, netdev, format, args...) \
2713 do { \ 2713 do { \
2714 if (netif_msg_##type(priv)) \ 2714 if (netif_msg_##type(priv)) \
2715 dynamic_dev_dbg((netdev)->dev.parent, \ 2715 dynamic_dev_dbg((netdev)->dev.parent, \
2716 "%s: " format, \ 2716 "%s: " format, \
2717 netdev_name(netdev), ##args); \ 2717 netdev_name(netdev), ##args); \
2718 } while (0) 2718 } while (0)
2719 #else 2719 #else
2720 #define netif_dbg(priv, type, dev, format, args...) \ 2720 #define netif_dbg(priv, type, dev, format, args...) \
2721 ({ \ 2721 ({ \
2722 if (0) \ 2722 if (0) \
2723 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \ 2723 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
2724 0; \ 2724 0; \
2725 }) 2725 })
2726 #endif 2726 #endif
2727 2727
2728 #if defined(VERBOSE_DEBUG) 2728 #if defined(VERBOSE_DEBUG)
2729 #define netif_vdbg netif_dbg 2729 #define netif_vdbg netif_dbg
2730 #else 2730 #else
2731 #define netif_vdbg(priv, type, dev, format, args...) \ 2731 #define netif_vdbg(priv, type, dev, format, args...) \
2732 ({ \ 2732 ({ \
2733 if (0) \ 2733 if (0) \
2734 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \ 2734 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
2735 0; \ 2735 0; \
2736 }) 2736 })
2737 #endif 2737 #endif
2738 2738
2739 #endif /* __KERNEL__ */ 2739 #endif /* __KERNEL__ */
2740 2740
2741 #endif /* _LINUX_NETDEVICE_H */ 2741 #endif /* _LINUX_NETDEVICE_H */
2742 2742
include/linux/pm_qos.h
Diff comments   View file @ cc74998
1 #ifndef _LINUX_PM_QOS_H 1 #ifndef _LINUX_PM_QOS_H
2 #define _LINUX_PM_QOS_H 2 #define _LINUX_PM_QOS_H
3 /* interface for the pm_qos_power infrastructure of the linux kernel. 3 /* interface for the pm_qos_power infrastructure of the linux kernel.
4 * 4 *
5 * Mark Gross <mgross@linux.intel.com> 5 * Mark Gross <mgross@linux.intel.com>
6 */ 6 */
7 #include <linux/plist.h> 7 #include <linux/plist.h>
8 #include <linux/notifier.h> 8 #include <linux/notifier.h>
9 #include <linux/miscdevice.h> 9 #include <linux/miscdevice.h>
10 10
11 #define PM_QOS_RESERVED 0 11 #define PM_QOS_RESERVED 0
12 #define PM_QOS_CPU_DMA_LATENCY 1 12 #define PM_QOS_CPU_DMA_LATENCY 1
13 #define PM_QOS_NETWORK_LATENCY 2 13 #define PM_QOS_NETWORK_LATENCY 2
14 #define PM_QOS_NETWORK_THROUGHPUT 3 14 #define PM_QOS_NETWORK_THROUGHPUT 3
15 15
16 #define PM_QOS_NUM_CLASSES 4 16 #define PM_QOS_NUM_CLASSES 4
17 #define PM_QOS_DEFAULT_VALUE -1 17 #define PM_QOS_DEFAULT_VALUE -1
18 18
19 #define PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE (2000 * USEC_PER_SEC) 19 #define PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE (2000 * USEC_PER_SEC)
20 #define PM_QOS_NETWORK_LAT_DEFAULT_VALUE (2000 * USEC_PER_SEC) 20 #define PM_QOS_NETWORK_LAT_DEFAULT_VALUE (2000 * USEC_PER_SEC)
21 #define PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE 0 21 #define PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE 0
22 22
23 struct pm_qos_request_list { 23 struct pm_qos_request {
24 struct plist_node list; 24 struct plist_node node;
25 int pm_qos_class; 25 int pm_qos_class;
26 }; 26 };
27 27
28 #ifdef CONFIG_PM 28 #ifdef CONFIG_PM
29 void pm_qos_add_request(struct pm_qos_request_list *l, 29 void pm_qos_add_request(struct pm_qos_request *req, int pm_qos_class,
30 int pm_qos_class, s32 value); 30 s32 value);
31 void pm_qos_update_request(struct pm_qos_request_list *pm_qos_req, 31 void pm_qos_update_request(struct pm_qos_request *req,
32 s32 new_value); 32 s32 new_value);
33 void pm_qos_remove_request(struct pm_qos_request_list *pm_qos_req); 33 void pm_qos_remove_request(struct pm_qos_request *req);
34 34
35 int pm_qos_request(int pm_qos_class); 35 int pm_qos_request(int pm_qos_class);
36 int pm_qos_add_notifier(int pm_qos_class, struct notifier_block *notifier); 36 int pm_qos_add_notifier(int pm_qos_class, struct notifier_block *notifier);
37 int pm_qos_remove_notifier(int pm_qos_class, struct notifier_block *notifier); 37 int pm_qos_remove_notifier(int pm_qos_class, struct notifier_block *notifier);
38 int pm_qos_request_active(struct pm_qos_request_list *req); 38 int pm_qos_request_active(struct pm_qos_request *req);
39 #else 39 #else
40 static inline void pm_qos_add_request(struct pm_qos_request_list *l, 40 static inline void pm_qos_add_request(struct pm_qos_request *req,
41 int pm_qos_class, s32 value) 41 int pm_qos_class, s32 value)
42 { return; } 42 { return; }
43 static inline void pm_qos_update_request(struct pm_qos_request_list *pm_qos_req, 43 static inline void pm_qos_update_request(struct pm_qos_request *req,
44 s32 new_value) 44 s32 new_value)
45 { return; } 45 { return; }
46 static inline void pm_qos_remove_request(struct pm_qos_request_list *pm_qos_req) 46 static inline void pm_qos_remove_request(struct pm_qos_request *req)
47 { return; } 47 { return; }
48 48
49 static inline int pm_qos_request(int pm_qos_class) 49 static inline int pm_qos_request(int pm_qos_class)
50 { return 0; } 50 { return 0; }
51 static inline int pm_qos_add_notifier(int pm_qos_class, 51 static inline int pm_qos_add_notifier(int pm_qos_class,
52 struct notifier_block *notifier) 52 struct notifier_block *notifier)
53 { return 0; } 53 { return 0; }
54 static inline int pm_qos_remove_notifier(int pm_qos_class, 54 static inline int pm_qos_remove_notifier(int pm_qos_class,
55 struct notifier_block *notifier) 55 struct notifier_block *notifier)
56 { return 0; } 56 { return 0; }
57 static inline int pm_qos_request_active(struct pm_qos_request_list *req) 57 static inline int pm_qos_request_active(struct pm_qos_request *req)
58 { return 0; } 58 { return 0; }
59 #endif 59 #endif
60 60
61 #endif 61 #endif
62 62
1 #ifndef __SOUND_PCM_H 1 #ifndef __SOUND_PCM_H
2 #define __SOUND_PCM_H 2 #define __SOUND_PCM_H
3 3
4 /* 4 /*
5 * Digital Audio (PCM) abstract layer 5 * Digital Audio (PCM) abstract layer
6 * Copyright (c) by Jaroslav Kysela <perex@perex.cz> 6 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
7 * Abramo Bagnara <abramo@alsa-project.org> 7 * Abramo Bagnara <abramo@alsa-project.org>
8 * 8 *
9 * 9 *
10 * This program is free software; you can redistribute it and/or modify 10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by 11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or 12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version. 13 * (at your option) any later version.
14 * 14 *
15 * This program is distributed in the hope that it will be useful, 15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details. 18 * GNU General Public License for more details.
19 * 19 *
20 * You should have received a copy of the GNU General Public License 20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software 21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 * 23 *
24 */ 24 */
25 25
26 #include <sound/asound.h> 26 #include <sound/asound.h>
27 #include <sound/memalloc.h> 27 #include <sound/memalloc.h>
28 #include <sound/minors.h> 28 #include <sound/minors.h>
29 #include <linux/poll.h> 29 #include <linux/poll.h>
30 #include <linux/mm.h> 30 #include <linux/mm.h>
31 #include <linux/bitops.h> 31 #include <linux/bitops.h>
32 #include <linux/pm_qos.h> 32 #include <linux/pm_qos.h>
33 33
34 #define snd_pcm_substream_chip(substream) ((substream)->private_data) 34 #define snd_pcm_substream_chip(substream) ((substream)->private_data)
35 #define snd_pcm_chip(pcm) ((pcm)->private_data) 35 #define snd_pcm_chip(pcm) ((pcm)->private_data)
36 36
37 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) 37 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
38 #include "pcm_oss.h" 38 #include "pcm_oss.h"
39 #endif 39 #endif
40 40
41 /* 41 /*
42 * Hardware (lowlevel) section 42 * Hardware (lowlevel) section
43 */ 43 */
44 44
45 struct snd_pcm_hardware { 45 struct snd_pcm_hardware {
46 unsigned int info; /* SNDRV_PCM_INFO_* */ 46 unsigned int info; /* SNDRV_PCM_INFO_* */
47 u64 formats; /* SNDRV_PCM_FMTBIT_* */ 47 u64 formats; /* SNDRV_PCM_FMTBIT_* */
48 unsigned int rates; /* SNDRV_PCM_RATE_* */ 48 unsigned int rates; /* SNDRV_PCM_RATE_* */
49 unsigned int rate_min; /* min rate */ 49 unsigned int rate_min; /* min rate */
50 unsigned int rate_max; /* max rate */ 50 unsigned int rate_max; /* max rate */
51 unsigned int channels_min; /* min channels */ 51 unsigned int channels_min; /* min channels */
52 unsigned int channels_max; /* max channels */ 52 unsigned int channels_max; /* max channels */
53 size_t buffer_bytes_max; /* max buffer size */ 53 size_t buffer_bytes_max; /* max buffer size */
54 size_t period_bytes_min; /* min period size */ 54 size_t period_bytes_min; /* min period size */
55 size_t period_bytes_max; /* max period size */ 55 size_t period_bytes_max; /* max period size */
56 unsigned int periods_min; /* min # of periods */ 56 unsigned int periods_min; /* min # of periods */
57 unsigned int periods_max; /* max # of periods */ 57 unsigned int periods_max; /* max # of periods */
58 size_t fifo_size; /* fifo size in bytes */ 58 size_t fifo_size; /* fifo size in bytes */
59 }; 59 };
60 60
61 struct snd_pcm_substream; 61 struct snd_pcm_substream;
62 62
63 struct snd_pcm_ops { 63 struct snd_pcm_ops {
64 int (*open)(struct snd_pcm_substream *substream); 64 int (*open)(struct snd_pcm_substream *substream);
65 int (*close)(struct snd_pcm_substream *substream); 65 int (*close)(struct snd_pcm_substream *substream);
66 int (*ioctl)(struct snd_pcm_substream * substream, 66 int (*ioctl)(struct snd_pcm_substream * substream,
67 unsigned int cmd, void *arg); 67 unsigned int cmd, void *arg);
68 int (*hw_params)(struct snd_pcm_substream *substream, 68 int (*hw_params)(struct snd_pcm_substream *substream,
69 struct snd_pcm_hw_params *params); 69 struct snd_pcm_hw_params *params);
70 int (*hw_free)(struct snd_pcm_substream *substream); 70 int (*hw_free)(struct snd_pcm_substream *substream);
71 int (*prepare)(struct snd_pcm_substream *substream); 71 int (*prepare)(struct snd_pcm_substream *substream);
72 int (*trigger)(struct snd_pcm_substream *substream, int cmd); 72 int (*trigger)(struct snd_pcm_substream *substream, int cmd);
73 snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *substream); 73 snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *substream);
74 int (*copy)(struct snd_pcm_substream *substream, int channel, 74 int (*copy)(struct snd_pcm_substream *substream, int channel,
75 snd_pcm_uframes_t pos, 75 snd_pcm_uframes_t pos,
76 void __user *buf, snd_pcm_uframes_t count); 76 void __user *buf, snd_pcm_uframes_t count);
77 int (*silence)(struct snd_pcm_substream *substream, int channel, 77 int (*silence)(struct snd_pcm_substream *substream, int channel,
78 snd_pcm_uframes_t pos, snd_pcm_uframes_t count); 78 snd_pcm_uframes_t pos, snd_pcm_uframes_t count);
79 struct page *(*page)(struct snd_pcm_substream *substream, 79 struct page *(*page)(struct snd_pcm_substream *substream,
80 unsigned long offset); 80 unsigned long offset);
81 int (*mmap)(struct snd_pcm_substream *substream, struct vm_area_struct *vma); 81 int (*mmap)(struct snd_pcm_substream *substream, struct vm_area_struct *vma);
82 int (*ack)(struct snd_pcm_substream *substream); 82 int (*ack)(struct snd_pcm_substream *substream);
83 }; 83 };
84 84
85 /* 85 /*
86 * 86 *
87 */ 87 */
88 88
89 #if defined(CONFIG_SND_DYNAMIC_MINORS) 89 #if defined(CONFIG_SND_DYNAMIC_MINORS)
90 #define SNDRV_PCM_DEVICES (SNDRV_OS_MINORS-2) 90 #define SNDRV_PCM_DEVICES (SNDRV_OS_MINORS-2)
91 #else 91 #else
92 #define SNDRV_PCM_DEVICES 8 92 #define SNDRV_PCM_DEVICES 8
93 #endif 93 #endif
94 94
95 #define SNDRV_PCM_IOCTL1_FALSE ((void *)0) 95 #define SNDRV_PCM_IOCTL1_FALSE ((void *)0)
96 #define SNDRV_PCM_IOCTL1_TRUE ((void *)1) 96 #define SNDRV_PCM_IOCTL1_TRUE ((void *)1)
97 97
98 #define SNDRV_PCM_IOCTL1_RESET 0 98 #define SNDRV_PCM_IOCTL1_RESET 0
99 #define SNDRV_PCM_IOCTL1_INFO 1 99 #define SNDRV_PCM_IOCTL1_INFO 1
100 #define SNDRV_PCM_IOCTL1_CHANNEL_INFO 2 100 #define SNDRV_PCM_IOCTL1_CHANNEL_INFO 2
101 #define SNDRV_PCM_IOCTL1_GSTATE 3 101 #define SNDRV_PCM_IOCTL1_GSTATE 3
102 #define SNDRV_PCM_IOCTL1_FIFO_SIZE 4 102 #define SNDRV_PCM_IOCTL1_FIFO_SIZE 4
103 103
104 #define SNDRV_PCM_TRIGGER_STOP 0 104 #define SNDRV_PCM_TRIGGER_STOP 0
105 #define SNDRV_PCM_TRIGGER_START 1 105 #define SNDRV_PCM_TRIGGER_START 1
106 #define SNDRV_PCM_TRIGGER_PAUSE_PUSH 3 106 #define SNDRV_PCM_TRIGGER_PAUSE_PUSH 3
107 #define SNDRV_PCM_TRIGGER_PAUSE_RELEASE 4 107 #define SNDRV_PCM_TRIGGER_PAUSE_RELEASE 4
108 #define SNDRV_PCM_TRIGGER_SUSPEND 5 108 #define SNDRV_PCM_TRIGGER_SUSPEND 5
109 #define SNDRV_PCM_TRIGGER_RESUME 6 109 #define SNDRV_PCM_TRIGGER_RESUME 6
110 110
111 #define SNDRV_PCM_POS_XRUN ((snd_pcm_uframes_t)-1) 111 #define SNDRV_PCM_POS_XRUN ((snd_pcm_uframes_t)-1)
112 112
113 /* If you change this don't forget to change rates[] table in pcm_native.c */ 113 /* If you change this don't forget to change rates[] table in pcm_native.c */
114 #define SNDRV_PCM_RATE_5512 (1<<0) /* 5512Hz */ 114 #define SNDRV_PCM_RATE_5512 (1<<0) /* 5512Hz */
115 #define SNDRV_PCM_RATE_8000 (1<<1) /* 8000Hz */ 115 #define SNDRV_PCM_RATE_8000 (1<<1) /* 8000Hz */
116 #define SNDRV_PCM_RATE_11025 (1<<2) /* 11025Hz */ 116 #define SNDRV_PCM_RATE_11025 (1<<2) /* 11025Hz */
117 #define SNDRV_PCM_RATE_16000 (1<<3) /* 16000Hz */ 117 #define SNDRV_PCM_RATE_16000 (1<<3) /* 16000Hz */
118 #define SNDRV_PCM_RATE_22050 (1<<4) /* 22050Hz */ 118 #define SNDRV_PCM_RATE_22050 (1<<4) /* 22050Hz */
119 #define SNDRV_PCM_RATE_32000 (1<<5) /* 32000Hz */ 119 #define SNDRV_PCM_RATE_32000 (1<<5) /* 32000Hz */
120 #define SNDRV_PCM_RATE_44100 (1<<6) /* 44100Hz */ 120 #define SNDRV_PCM_RATE_44100 (1<<6) /* 44100Hz */
121 #define SNDRV_PCM_RATE_48000 (1<<7) /* 48000Hz */ 121 #define SNDRV_PCM_RATE_48000 (1<<7) /* 48000Hz */
122 #define SNDRV_PCM_RATE_64000 (1<<8) /* 64000Hz */ 122 #define SNDRV_PCM_RATE_64000 (1<<8) /* 64000Hz */
123 #define SNDRV_PCM_RATE_88200 (1<<9) /* 88200Hz */ 123 #define SNDRV_PCM_RATE_88200 (1<<9) /* 88200Hz */
124 #define SNDRV_PCM_RATE_96000 (1<<10) /* 96000Hz */ 124 #define SNDRV_PCM_RATE_96000 (1<<10) /* 96000Hz */
125 #define SNDRV_PCM_RATE_176400 (1<<11) /* 176400Hz */ 125 #define SNDRV_PCM_RATE_176400 (1<<11) /* 176400Hz */
126 #define SNDRV_PCM_RATE_192000 (1<<12) /* 192000Hz */ 126 #define SNDRV_PCM_RATE_192000 (1<<12) /* 192000Hz */
127 127
128 #define SNDRV_PCM_RATE_CONTINUOUS (1<<30) /* continuous range */ 128 #define SNDRV_PCM_RATE_CONTINUOUS (1<<30) /* continuous range */
129 #define SNDRV_PCM_RATE_KNOT (1<<31) /* supports more non-continuos rates */ 129 #define SNDRV_PCM_RATE_KNOT (1<<31) /* supports more non-continuos rates */
130 130
131 #define SNDRV_PCM_RATE_8000_44100 (SNDRV_PCM_RATE_8000|SNDRV_PCM_RATE_11025|\ 131 #define SNDRV_PCM_RATE_8000_44100 (SNDRV_PCM_RATE_8000|SNDRV_PCM_RATE_11025|\
132 SNDRV_PCM_RATE_16000|SNDRV_PCM_RATE_22050|\ 132 SNDRV_PCM_RATE_16000|SNDRV_PCM_RATE_22050|\
133 SNDRV_PCM_RATE_32000|SNDRV_PCM_RATE_44100) 133 SNDRV_PCM_RATE_32000|SNDRV_PCM_RATE_44100)
134 #define SNDRV_PCM_RATE_8000_48000 (SNDRV_PCM_RATE_8000_44100|SNDRV_PCM_RATE_48000) 134 #define SNDRV_PCM_RATE_8000_48000 (SNDRV_PCM_RATE_8000_44100|SNDRV_PCM_RATE_48000)
135 #define SNDRV_PCM_RATE_8000_96000 (SNDRV_PCM_RATE_8000_48000|SNDRV_PCM_RATE_64000|\ 135 #define SNDRV_PCM_RATE_8000_96000 (SNDRV_PCM_RATE_8000_48000|SNDRV_PCM_RATE_64000|\
136 SNDRV_PCM_RATE_88200|SNDRV_PCM_RATE_96000) 136 SNDRV_PCM_RATE_88200|SNDRV_PCM_RATE_96000)
137 #define SNDRV_PCM_RATE_8000_192000 (SNDRV_PCM_RATE_8000_96000|SNDRV_PCM_RATE_176400|\ 137 #define SNDRV_PCM_RATE_8000_192000 (SNDRV_PCM_RATE_8000_96000|SNDRV_PCM_RATE_176400|\
138 SNDRV_PCM_RATE_192000) 138 SNDRV_PCM_RATE_192000)
139 #define _SNDRV_PCM_FMTBIT(fmt) (1ULL << (__force int)SNDRV_PCM_FORMAT_##fmt) 139 #define _SNDRV_PCM_FMTBIT(fmt) (1ULL << (__force int)SNDRV_PCM_FORMAT_##fmt)
140 #define SNDRV_PCM_FMTBIT_S8 _SNDRV_PCM_FMTBIT(S8) 140 #define SNDRV_PCM_FMTBIT_S8 _SNDRV_PCM_FMTBIT(S8)
141 #define SNDRV_PCM_FMTBIT_U8 _SNDRV_PCM_FMTBIT(U8) 141 #define SNDRV_PCM_FMTBIT_U8 _SNDRV_PCM_FMTBIT(U8)
142 #define SNDRV_PCM_FMTBIT_S16_LE _SNDRV_PCM_FMTBIT(S16_LE) 142 #define SNDRV_PCM_FMTBIT_S16_LE _SNDRV_PCM_FMTBIT(S16_LE)
143 #define SNDRV_PCM_FMTBIT_S16_BE _SNDRV_PCM_FMTBIT(S16_BE) 143 #define SNDRV_PCM_FMTBIT_S16_BE _SNDRV_PCM_FMTBIT(S16_BE)
144 #define SNDRV_PCM_FMTBIT_U16_LE _SNDRV_PCM_FMTBIT(U16_LE) 144 #define SNDRV_PCM_FMTBIT_U16_LE _SNDRV_PCM_FMTBIT(U16_LE)
145 #define SNDRV_PCM_FMTBIT_U16_BE _SNDRV_PCM_FMTBIT(U16_BE) 145 #define SNDRV_PCM_FMTBIT_U16_BE _SNDRV_PCM_FMTBIT(U16_BE)
146 #define SNDRV_PCM_FMTBIT_S24_LE _SNDRV_PCM_FMTBIT(S24_LE) 146 #define SNDRV_PCM_FMTBIT_S24_LE _SNDRV_PCM_FMTBIT(S24_LE)
147 #define SNDRV_PCM_FMTBIT_S24_BE _SNDRV_PCM_FMTBIT(S24_BE) 147 #define SNDRV_PCM_FMTBIT_S24_BE _SNDRV_PCM_FMTBIT(S24_BE)
148 #define SNDRV_PCM_FMTBIT_U24_LE _SNDRV_PCM_FMTBIT(U24_LE) 148 #define SNDRV_PCM_FMTBIT_U24_LE _SNDRV_PCM_FMTBIT(U24_LE)
149 #define SNDRV_PCM_FMTBIT_U24_BE _SNDRV_PCM_FMTBIT(U24_BE) 149 #define SNDRV_PCM_FMTBIT_U24_BE _SNDRV_PCM_FMTBIT(U24_BE)
150 #define SNDRV_PCM_FMTBIT_S32_LE _SNDRV_PCM_FMTBIT(S32_LE) 150 #define SNDRV_PCM_FMTBIT_S32_LE _SNDRV_PCM_FMTBIT(S32_LE)
151 #define SNDRV_PCM_FMTBIT_S32_BE _SNDRV_PCM_FMTBIT(S32_BE) 151 #define SNDRV_PCM_FMTBIT_S32_BE _SNDRV_PCM_FMTBIT(S32_BE)
152 #define SNDRV_PCM_FMTBIT_U32_LE _SNDRV_PCM_FMTBIT(U32_LE) 152 #define SNDRV_PCM_FMTBIT_U32_LE _SNDRV_PCM_FMTBIT(U32_LE)
153 #define SNDRV_PCM_FMTBIT_U32_BE _SNDRV_PCM_FMTBIT(U32_BE) 153 #define SNDRV_PCM_FMTBIT_U32_BE _SNDRV_PCM_FMTBIT(U32_BE)
154 #define SNDRV_PCM_FMTBIT_FLOAT_LE _SNDRV_PCM_FMTBIT(FLOAT_LE) 154 #define SNDRV_PCM_FMTBIT_FLOAT_LE _SNDRV_PCM_FMTBIT(FLOAT_LE)
155 #define SNDRV_PCM_FMTBIT_FLOAT_BE _SNDRV_PCM_FMTBIT(FLOAT_BE) 155 #define SNDRV_PCM_FMTBIT_FLOAT_BE _SNDRV_PCM_FMTBIT(FLOAT_BE)
156 #define SNDRV_PCM_FMTBIT_FLOAT64_LE _SNDRV_PCM_FMTBIT(FLOAT64_LE) 156 #define SNDRV_PCM_FMTBIT_FLOAT64_LE _SNDRV_PCM_FMTBIT(FLOAT64_LE)
157 #define SNDRV_PCM_FMTBIT_FLOAT64_BE _SNDRV_PCM_FMTBIT(FLOAT64_BE) 157 #define SNDRV_PCM_FMTBIT_FLOAT64_BE _SNDRV_PCM_FMTBIT(FLOAT64_BE)
158 #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE _SNDRV_PCM_FMTBIT(IEC958_SUBFRAME_LE) 158 #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE _SNDRV_PCM_FMTBIT(IEC958_SUBFRAME_LE)
159 #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE _SNDRV_PCM_FMTBIT(IEC958_SUBFRAME_BE) 159 #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE _SNDRV_PCM_FMTBIT(IEC958_SUBFRAME_BE)
160 #define SNDRV_PCM_FMTBIT_MU_LAW _SNDRV_PCM_FMTBIT(MU_LAW) 160 #define SNDRV_PCM_FMTBIT_MU_LAW _SNDRV_PCM_FMTBIT(MU_LAW)
161 #define SNDRV_PCM_FMTBIT_A_LAW _SNDRV_PCM_FMTBIT(A_LAW) 161 #define SNDRV_PCM_FMTBIT_A_LAW _SNDRV_PCM_FMTBIT(A_LAW)
162 #define SNDRV_PCM_FMTBIT_IMA_ADPCM _SNDRV_PCM_FMTBIT(IMA_ADPCM) 162 #define SNDRV_PCM_FMTBIT_IMA_ADPCM _SNDRV_PCM_FMTBIT(IMA_ADPCM)
163 #define SNDRV_PCM_FMTBIT_MPEG _SNDRV_PCM_FMTBIT(MPEG) 163 #define SNDRV_PCM_FMTBIT_MPEG _SNDRV_PCM_FMTBIT(MPEG)
164 #define SNDRV_PCM_FMTBIT_GSM _SNDRV_PCM_FMTBIT(GSM) 164 #define SNDRV_PCM_FMTBIT_GSM _SNDRV_PCM_FMTBIT(GSM)
165 #define SNDRV_PCM_FMTBIT_SPECIAL _SNDRV_PCM_FMTBIT(SPECIAL) 165 #define SNDRV_PCM_FMTBIT_SPECIAL _SNDRV_PCM_FMTBIT(SPECIAL)
166 #define SNDRV_PCM_FMTBIT_S24_3LE _SNDRV_PCM_FMTBIT(S24_3LE) 166 #define SNDRV_PCM_FMTBIT_S24_3LE _SNDRV_PCM_FMTBIT(S24_3LE)
167 #define SNDRV_PCM_FMTBIT_U24_3LE _SNDRV_PCM_FMTBIT(U24_3LE) 167 #define SNDRV_PCM_FMTBIT_U24_3LE _SNDRV_PCM_FMTBIT(U24_3LE)
168 #define SNDRV_PCM_FMTBIT_S24_3BE _SNDRV_PCM_FMTBIT(S24_3BE) 168 #define SNDRV_PCM_FMTBIT_S24_3BE _SNDRV_PCM_FMTBIT(S24_3BE)
169 #define SNDRV_PCM_FMTBIT_U24_3BE _SNDRV_PCM_FMTBIT(U24_3BE) 169 #define SNDRV_PCM_FMTBIT_U24_3BE _SNDRV_PCM_FMTBIT(U24_3BE)
170 #define SNDRV_PCM_FMTBIT_S20_3LE _SNDRV_PCM_FMTBIT(S20_3LE) 170 #define SNDRV_PCM_FMTBIT_S20_3LE _SNDRV_PCM_FMTBIT(S20_3LE)
171 #define SNDRV_PCM_FMTBIT_U20_3LE _SNDRV_PCM_FMTBIT(U20_3LE) 171 #define SNDRV_PCM_FMTBIT_U20_3LE _SNDRV_PCM_FMTBIT(U20_3LE)
172 #define SNDRV_PCM_FMTBIT_S20_3BE _SNDRV_PCM_FMTBIT(S20_3BE) 172 #define SNDRV_PCM_FMTBIT_S20_3BE _SNDRV_PCM_FMTBIT(S20_3BE)
173 #define SNDRV_PCM_FMTBIT_U20_3BE _SNDRV_PCM_FMTBIT(U20_3BE) 173 #define SNDRV_PCM_FMTBIT_U20_3BE _SNDRV_PCM_FMTBIT(U20_3BE)
174 #define SNDRV_PCM_FMTBIT_S18_3LE _SNDRV_PCM_FMTBIT(S18_3LE) 174 #define SNDRV_PCM_FMTBIT_S18_3LE _SNDRV_PCM_FMTBIT(S18_3LE)
175 #define SNDRV_PCM_FMTBIT_U18_3LE _SNDRV_PCM_FMTBIT(U18_3LE) 175 #define SNDRV_PCM_FMTBIT_U18_3LE _SNDRV_PCM_FMTBIT(U18_3LE)
176 #define SNDRV_PCM_FMTBIT_S18_3BE _SNDRV_PCM_FMTBIT(S18_3BE) 176 #define SNDRV_PCM_FMTBIT_S18_3BE _SNDRV_PCM_FMTBIT(S18_3BE)
177 #define SNDRV_PCM_FMTBIT_U18_3BE _SNDRV_PCM_FMTBIT(U18_3BE) 177 #define SNDRV_PCM_FMTBIT_U18_3BE _SNDRV_PCM_FMTBIT(U18_3BE)
178 #define SNDRV_PCM_FMTBIT_G723_24 _SNDRV_PCM_FMTBIT(G723_24) 178 #define SNDRV_PCM_FMTBIT_G723_24 _SNDRV_PCM_FMTBIT(G723_24)
179 #define SNDRV_PCM_FMTBIT_G723_24_1B _SNDRV_PCM_FMTBIT(G723_24_1B) 179 #define SNDRV_PCM_FMTBIT_G723_24_1B _SNDRV_PCM_FMTBIT(G723_24_1B)
180 #define SNDRV_PCM_FMTBIT_G723_40 _SNDRV_PCM_FMTBIT(G723_40) 180 #define SNDRV_PCM_FMTBIT_G723_40 _SNDRV_PCM_FMTBIT(G723_40)
181 #define SNDRV_PCM_FMTBIT_G723_40_1B _SNDRV_PCM_FMTBIT(G723_40_1B) 181 #define SNDRV_PCM_FMTBIT_G723_40_1B _SNDRV_PCM_FMTBIT(G723_40_1B)
182 182
183 #ifdef SNDRV_LITTLE_ENDIAN 183 #ifdef SNDRV_LITTLE_ENDIAN
184 #define SNDRV_PCM_FMTBIT_S16 SNDRV_PCM_FMTBIT_S16_LE 184 #define SNDRV_PCM_FMTBIT_S16 SNDRV_PCM_FMTBIT_S16_LE
185 #define SNDRV_PCM_FMTBIT_U16 SNDRV_PCM_FMTBIT_U16_LE 185 #define SNDRV_PCM_FMTBIT_U16 SNDRV_PCM_FMTBIT_U16_LE
186 #define SNDRV_PCM_FMTBIT_S24 SNDRV_PCM_FMTBIT_S24_LE 186 #define SNDRV_PCM_FMTBIT_S24 SNDRV_PCM_FMTBIT_S24_LE
187 #define SNDRV_PCM_FMTBIT_U24 SNDRV_PCM_FMTBIT_U24_LE 187 #define SNDRV_PCM_FMTBIT_U24 SNDRV_PCM_FMTBIT_U24_LE
188 #define SNDRV_PCM_FMTBIT_S32 SNDRV_PCM_FMTBIT_S32_LE 188 #define SNDRV_PCM_FMTBIT_S32 SNDRV_PCM_FMTBIT_S32_LE
189 #define SNDRV_PCM_FMTBIT_U32 SNDRV_PCM_FMTBIT_U32_LE 189 #define SNDRV_PCM_FMTBIT_U32 SNDRV_PCM_FMTBIT_U32_LE
190 #define SNDRV_PCM_FMTBIT_FLOAT SNDRV_PCM_FMTBIT_FLOAT_LE 190 #define SNDRV_PCM_FMTBIT_FLOAT SNDRV_PCM_FMTBIT_FLOAT_LE
191 #define SNDRV_PCM_FMTBIT_FLOAT64 SNDRV_PCM_FMTBIT_FLOAT64_LE 191 #define SNDRV_PCM_FMTBIT_FLOAT64 SNDRV_PCM_FMTBIT_FLOAT64_LE
192 #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE 192 #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
193 #endif 193 #endif
194 #ifdef SNDRV_BIG_ENDIAN 194 #ifdef SNDRV_BIG_ENDIAN
195 #define SNDRV_PCM_FMTBIT_S16 SNDRV_PCM_FMTBIT_S16_BE 195 #define SNDRV_PCM_FMTBIT_S16 SNDRV_PCM_FMTBIT_S16_BE
196 #define SNDRV_PCM_FMTBIT_U16 SNDRV_PCM_FMTBIT_U16_BE 196 #define SNDRV_PCM_FMTBIT_U16 SNDRV_PCM_FMTBIT_U16_BE
197 #define SNDRV_PCM_FMTBIT_S24 SNDRV_PCM_FMTBIT_S24_BE 197 #define SNDRV_PCM_FMTBIT_S24 SNDRV_PCM_FMTBIT_S24_BE
198 #define SNDRV_PCM_FMTBIT_U24 SNDRV_PCM_FMTBIT_U24_BE 198 #define SNDRV_PCM_FMTBIT_U24 SNDRV_PCM_FMTBIT_U24_BE
199 #define SNDRV_PCM_FMTBIT_S32 SNDRV_PCM_FMTBIT_S32_BE 199 #define SNDRV_PCM_FMTBIT_S32 SNDRV_PCM_FMTBIT_S32_BE
200 #define SNDRV_PCM_FMTBIT_U32 SNDRV_PCM_FMTBIT_U32_BE 200 #define SNDRV_PCM_FMTBIT_U32 SNDRV_PCM_FMTBIT_U32_BE
201 #define SNDRV_PCM_FMTBIT_FLOAT SNDRV_PCM_FMTBIT_FLOAT_BE 201 #define SNDRV_PCM_FMTBIT_FLOAT SNDRV_PCM_FMTBIT_FLOAT_BE
202 #define SNDRV_PCM_FMTBIT_FLOAT64 SNDRV_PCM_FMTBIT_FLOAT64_BE 202 #define SNDRV_PCM_FMTBIT_FLOAT64 SNDRV_PCM_FMTBIT_FLOAT64_BE
203 #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE 203 #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE
204 #endif 204 #endif
205 205
206 struct snd_pcm_file { 206 struct snd_pcm_file {
207 struct snd_pcm_substream *substream; 207 struct snd_pcm_substream *substream;
208 int no_compat_mmap; 208 int no_compat_mmap;
209 }; 209 };
210 210
211 struct snd_pcm_hw_rule; 211 struct snd_pcm_hw_rule;
212 typedef int (*snd_pcm_hw_rule_func_t)(struct snd_pcm_hw_params *params, 212 typedef int (*snd_pcm_hw_rule_func_t)(struct snd_pcm_hw_params *params,
213 struct snd_pcm_hw_rule *rule); 213 struct snd_pcm_hw_rule *rule);
214 214
215 struct snd_pcm_hw_rule { 215 struct snd_pcm_hw_rule {
216 unsigned int cond; 216 unsigned int cond;
217 snd_pcm_hw_rule_func_t func; 217 snd_pcm_hw_rule_func_t func;
218 int var; 218 int var;
219 int deps[4]; 219 int deps[4];
220 void *private; 220 void *private;
221 }; 221 };
222 222
223 struct snd_pcm_hw_constraints { 223 struct snd_pcm_hw_constraints {
224 struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - 224 struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK -
225 SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; 225 SNDRV_PCM_HW_PARAM_FIRST_MASK + 1];
226 struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - 226 struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL -
227 SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]; 227 SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1];
228 unsigned int rules_num; 228 unsigned int rules_num;
229 unsigned int rules_all; 229 unsigned int rules_all;
230 struct snd_pcm_hw_rule *rules; 230 struct snd_pcm_hw_rule *rules;
231 }; 231 };
232 232
233 static inline struct snd_mask *constrs_mask(struct snd_pcm_hw_constraints *constrs, 233 static inline struct snd_mask *constrs_mask(struct snd_pcm_hw_constraints *constrs,
234 snd_pcm_hw_param_t var) 234 snd_pcm_hw_param_t var)
235 { 235 {
236 return &constrs->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK]; 236 return &constrs->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK];
237 } 237 }
238 238
239 static inline struct snd_interval *constrs_interval(struct snd_pcm_hw_constraints *constrs, 239 static inline struct snd_interval *constrs_interval(struct snd_pcm_hw_constraints *constrs,
240 snd_pcm_hw_param_t var) 240 snd_pcm_hw_param_t var)
241 { 241 {
242 return &constrs->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL]; 242 return &constrs->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL];
243 } 243 }
244 244
245 struct snd_ratnum { 245 struct snd_ratnum {
246 unsigned int num; 246 unsigned int num;
247 unsigned int den_min, den_max, den_step; 247 unsigned int den_min, den_max, den_step;
248 }; 248 };
249 249
250 struct snd_ratden { 250 struct snd_ratden {
251 unsigned int num_min, num_max, num_step; 251 unsigned int num_min, num_max, num_step;
252 unsigned int den; 252 unsigned int den;
253 }; 253 };
254 254
255 struct snd_pcm_hw_constraint_ratnums { 255 struct snd_pcm_hw_constraint_ratnums {
256 int nrats; 256 int nrats;
257 struct snd_ratnum *rats; 257 struct snd_ratnum *rats;
258 }; 258 };
259 259
260 struct snd_pcm_hw_constraint_ratdens { 260 struct snd_pcm_hw_constraint_ratdens {
261 int nrats; 261 int nrats;
262 struct snd_ratden *rats; 262 struct snd_ratden *rats;
263 }; 263 };
264 264
265 struct snd_pcm_hw_constraint_list { 265 struct snd_pcm_hw_constraint_list {
266 unsigned int count; 266 unsigned int count;
267 unsigned int *list; 267 unsigned int *list;
268 unsigned int mask; 268 unsigned int mask;
269 }; 269 };
270 270
271 struct snd_pcm_hwptr_log; 271 struct snd_pcm_hwptr_log;
272 272
273 struct snd_pcm_runtime { 273 struct snd_pcm_runtime {
274 /* -- Status -- */ 274 /* -- Status -- */
275 struct snd_pcm_substream *trigger_master; 275 struct snd_pcm_substream *trigger_master;
276 struct timespec trigger_tstamp; /* trigger timestamp */ 276 struct timespec trigger_tstamp; /* trigger timestamp */
277 int overrange; 277 int overrange;
278 snd_pcm_uframes_t avail_max; 278 snd_pcm_uframes_t avail_max;
279 snd_pcm_uframes_t hw_ptr_base; /* Position at buffer restart */ 279 snd_pcm_uframes_t hw_ptr_base; /* Position at buffer restart */
280 snd_pcm_uframes_t hw_ptr_interrupt; /* Position at interrupt time */ 280 snd_pcm_uframes_t hw_ptr_interrupt; /* Position at interrupt time */
281 unsigned long hw_ptr_jiffies; /* Time when hw_ptr is updated */ 281 unsigned long hw_ptr_jiffies; /* Time when hw_ptr is updated */
282 unsigned long hw_ptr_buffer_jiffies; /* buffer time in jiffies */ 282 unsigned long hw_ptr_buffer_jiffies; /* buffer time in jiffies */
283 snd_pcm_sframes_t delay; /* extra delay; typically FIFO size */ 283 snd_pcm_sframes_t delay; /* extra delay; typically FIFO size */
284 284
285 /* -- HW params -- */ 285 /* -- HW params -- */
286 snd_pcm_access_t access; /* access mode */ 286 snd_pcm_access_t access; /* access mode */
287 snd_pcm_format_t format; /* SNDRV_PCM_FORMAT_* */ 287 snd_pcm_format_t format; /* SNDRV_PCM_FORMAT_* */
288 snd_pcm_subformat_t subformat; /* subformat */ 288 snd_pcm_subformat_t subformat; /* subformat */
289 unsigned int rate; /* rate in Hz */ 289 unsigned int rate; /* rate in Hz */
290 unsigned int channels; /* channels */ 290 unsigned int channels; /* channels */
291 snd_pcm_uframes_t period_size; /* period size */ 291 snd_pcm_uframes_t period_size; /* period size */
292 unsigned int periods; /* periods */ 292 unsigned int periods; /* periods */
293 snd_pcm_uframes_t buffer_size; /* buffer size */ 293 snd_pcm_uframes_t buffer_size; /* buffer size */
294 snd_pcm_uframes_t min_align; /* Min alignment for the format */ 294 snd_pcm_uframes_t min_align; /* Min alignment for the format */
295 size_t byte_align; 295 size_t byte_align;
296 unsigned int frame_bits; 296 unsigned int frame_bits;
297 unsigned int sample_bits; 297 unsigned int sample_bits;
298 unsigned int info; 298 unsigned int info;
299 unsigned int rate_num; 299 unsigned int rate_num;
300 unsigned int rate_den; 300 unsigned int rate_den;
301 unsigned int no_period_wakeup: 1; 301 unsigned int no_period_wakeup: 1;
302 302
303 /* -- SW params -- */ 303 /* -- SW params -- */
304 int tstamp_mode; /* mmap timestamp is updated */ 304 int tstamp_mode; /* mmap timestamp is updated */
305 unsigned int period_step; 305 unsigned int period_step;
306 snd_pcm_uframes_t start_threshold; 306 snd_pcm_uframes_t start_threshold;
307 snd_pcm_uframes_t stop_threshold; 307 snd_pcm_uframes_t stop_threshold;
308 snd_pcm_uframes_t silence_threshold; /* Silence filling happens when 308 snd_pcm_uframes_t silence_threshold; /* Silence filling happens when
309 noise is nearest than this */ 309 noise is nearest than this */
310 snd_pcm_uframes_t silence_size; /* Silence filling size */ 310 snd_pcm_uframes_t silence_size; /* Silence filling size */
311 snd_pcm_uframes_t boundary; /* pointers wrap point */ 311 snd_pcm_uframes_t boundary; /* pointers wrap point */
312 312
313 snd_pcm_uframes_t silence_start; /* starting pointer to silence area */ 313 snd_pcm_uframes_t silence_start; /* starting pointer to silence area */
314 snd_pcm_uframes_t silence_filled; /* size filled with silence */ 314 snd_pcm_uframes_t silence_filled; /* size filled with silence */
315 315
316 union snd_pcm_sync_id sync; /* hardware synchronization ID */ 316 union snd_pcm_sync_id sync; /* hardware synchronization ID */
317 317
318 /* -- mmap -- */ 318 /* -- mmap -- */
319 struct snd_pcm_mmap_status *status; 319 struct snd_pcm_mmap_status *status;
320 struct snd_pcm_mmap_control *control; 320 struct snd_pcm_mmap_control *control;
321 321
322 /* -- locking / scheduling -- */ 322 /* -- locking / scheduling -- */
323 snd_pcm_uframes_t twake; /* do transfer (!poll) wakeup if non-zero */ 323 snd_pcm_uframes_t twake; /* do transfer (!poll) wakeup if non-zero */
324 wait_queue_head_t sleep; /* poll sleep */ 324 wait_queue_head_t sleep; /* poll sleep */
325 wait_queue_head_t tsleep; /* transfer sleep */ 325 wait_queue_head_t tsleep; /* transfer sleep */
326 struct fasync_struct *fasync; 326 struct fasync_struct *fasync;
327 327
328 /* -- private section -- */ 328 /* -- private section -- */
329 void *private_data; 329 void *private_data;
330 void (*private_free)(struct snd_pcm_runtime *runtime); 330 void (*private_free)(struct snd_pcm_runtime *runtime);
331 331
332 /* -- hardware description -- */ 332 /* -- hardware description -- */
333 struct snd_pcm_hardware hw; 333 struct snd_pcm_hardware hw;
334 struct snd_pcm_hw_constraints hw_constraints; 334 struct snd_pcm_hw_constraints hw_constraints;
335 335
336 /* -- interrupt callbacks -- */ 336 /* -- interrupt callbacks -- */
337 void (*transfer_ack_begin)(struct snd_pcm_substream *substream); 337 void (*transfer_ack_begin)(struct snd_pcm_substream *substream);
338 void (*transfer_ack_end)(struct snd_pcm_substream *substream); 338 void (*transfer_ack_end)(struct snd_pcm_substream *substream);
339 339
340 /* -- timer -- */ 340 /* -- timer -- */
341 unsigned int timer_resolution; /* timer resolution */ 341 unsigned int timer_resolution; /* timer resolution */
342 int tstamp_type; /* timestamp type */ 342 int tstamp_type; /* timestamp type */
343 343
344 /* -- DMA -- */ 344 /* -- DMA -- */
345 unsigned char *dma_area; /* DMA area */ 345 unsigned char *dma_area; /* DMA area */
346 dma_addr_t dma_addr; /* physical bus address (not accessible from main CPU) */ 346 dma_addr_t dma_addr; /* physical bus address (not accessible from main CPU) */
347 size_t dma_bytes; /* size of DMA area */ 347 size_t dma_bytes; /* size of DMA area */
348 348
349 struct snd_dma_buffer *dma_buffer_p; /* allocated buffer */ 349 struct snd_dma_buffer *dma_buffer_p; /* allocated buffer */
350 350
351 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) 351 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
352 /* -- OSS things -- */ 352 /* -- OSS things -- */
353 struct snd_pcm_oss_runtime oss; 353 struct snd_pcm_oss_runtime oss;
354 #endif 354 #endif
355 355
356 #ifdef CONFIG_SND_PCM_XRUN_DEBUG 356 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
357 struct snd_pcm_hwptr_log *hwptr_log; 357 struct snd_pcm_hwptr_log *hwptr_log;
358 #endif 358 #endif
359 }; 359 };
360 360
361 struct snd_pcm_group { /* keep linked substreams */ 361 struct snd_pcm_group { /* keep linked substreams */
362 spinlock_t lock; 362 spinlock_t lock;
363 struct list_head substreams; 363 struct list_head substreams;
364 int count; 364 int count;
365 }; 365 };
366 366
367 struct pid; 367 struct pid;
368 368
369 struct snd_pcm_substream { 369 struct snd_pcm_substream {
370 struct snd_pcm *pcm; 370 struct snd_pcm *pcm;
371 struct snd_pcm_str *pstr; 371 struct snd_pcm_str *pstr;
372 void *private_data; /* copied from pcm->private_data */ 372 void *private_data; /* copied from pcm->private_data */
373 int number; 373 int number;
374 char name[32]; /* substream name */ 374 char name[32]; /* substream name */
375 int stream; /* stream (direction) */ 375 int stream; /* stream (direction) */
376 struct pm_qos_request_list latency_pm_qos_req; /* pm_qos request */ 376 struct pm_qos_request latency_pm_qos_req; /* pm_qos request */
377 size_t buffer_bytes_max; /* limit ring buffer size */ 377 size_t buffer_bytes_max; /* limit ring buffer size */
378 struct snd_dma_buffer dma_buffer; 378 struct snd_dma_buffer dma_buffer;
379 unsigned int dma_buf_id; 379 unsigned int dma_buf_id;
380 size_t dma_max; 380 size_t dma_max;
381 /* -- hardware operations -- */ 381 /* -- hardware operations -- */
382 struct snd_pcm_ops *ops; 382 struct snd_pcm_ops *ops;
383 /* -- runtime information -- */ 383 /* -- runtime information -- */
384 struct snd_pcm_runtime *runtime; 384 struct snd_pcm_runtime *runtime;
385 /* -- timer section -- */ 385 /* -- timer section -- */
386 struct snd_timer *timer; /* timer */ 386 struct snd_timer *timer; /* timer */
387 unsigned timer_running: 1; /* time is running */ 387 unsigned timer_running: 1; /* time is running */
388 /* -- next substream -- */ 388 /* -- next substream -- */
389 struct snd_pcm_substream *next; 389 struct snd_pcm_substream *next;
390 /* -- linked substreams -- */ 390 /* -- linked substreams -- */
391 struct list_head link_list; /* linked list member */ 391 struct list_head link_list; /* linked list member */
392 struct snd_pcm_group self_group; /* fake group for non linked substream (with substream lock inside) */ 392 struct snd_pcm_group self_group; /* fake group for non linked substream (with substream lock inside) */
393 struct snd_pcm_group *group; /* pointer to current group */ 393 struct snd_pcm_group *group; /* pointer to current group */
394 /* -- assigned files -- */ 394 /* -- assigned files -- */
395 void *file; 395 void *file;
396 int ref_count; 396 int ref_count;
397 atomic_t mmap_count; 397 atomic_t mmap_count;
398 unsigned int f_flags; 398 unsigned int f_flags;
399 void (*pcm_release)(struct snd_pcm_substream *); 399 void (*pcm_release)(struct snd_pcm_substream *);
400 struct pid *pid; 400 struct pid *pid;
401 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) 401 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
402 /* -- OSS things -- */ 402 /* -- OSS things -- */
403 struct snd_pcm_oss_substream oss; 403 struct snd_pcm_oss_substream oss;
404 #endif 404 #endif
405 #ifdef CONFIG_SND_VERBOSE_PROCFS 405 #ifdef CONFIG_SND_VERBOSE_PROCFS
406 struct snd_info_entry *proc_root; 406 struct snd_info_entry *proc_root;
407 struct snd_info_entry *proc_info_entry; 407 struct snd_info_entry *proc_info_entry;
408 struct snd_info_entry *proc_hw_params_entry; 408 struct snd_info_entry *proc_hw_params_entry;
409 struct snd_info_entry *proc_sw_params_entry; 409 struct snd_info_entry *proc_sw_params_entry;
410 struct snd_info_entry *proc_status_entry; 410 struct snd_info_entry *proc_status_entry;
411 struct snd_info_entry *proc_prealloc_entry; 411 struct snd_info_entry *proc_prealloc_entry;
412 struct snd_info_entry *proc_prealloc_max_entry; 412 struct snd_info_entry *proc_prealloc_max_entry;
413 #endif 413 #endif
414 /* misc flags */ 414 /* misc flags */
415 unsigned int hw_opened: 1; 415 unsigned int hw_opened: 1;
416 }; 416 };
417 417
418 #define SUBSTREAM_BUSY(substream) ((substream)->ref_count > 0) 418 #define SUBSTREAM_BUSY(substream) ((substream)->ref_count > 0)
419 419
420 420
421 struct snd_pcm_str { 421 struct snd_pcm_str {
422 int stream; /* stream (direction) */ 422 int stream; /* stream (direction) */
423 struct snd_pcm *pcm; 423 struct snd_pcm *pcm;
424 /* -- substreams -- */ 424 /* -- substreams -- */
425 unsigned int substream_count; 425 unsigned int substream_count;
426 unsigned int substream_opened; 426 unsigned int substream_opened;
427 struct snd_pcm_substream *substream; 427 struct snd_pcm_substream *substream;
428 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) 428 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
429 /* -- OSS things -- */ 429 /* -- OSS things -- */
430 struct snd_pcm_oss_stream oss; 430 struct snd_pcm_oss_stream oss;
431 #endif 431 #endif
432 #ifdef CONFIG_SND_VERBOSE_PROCFS 432 #ifdef CONFIG_SND_VERBOSE_PROCFS
433 struct snd_info_entry *proc_root; 433 struct snd_info_entry *proc_root;
434 struct snd_info_entry *proc_info_entry; 434 struct snd_info_entry *proc_info_entry;
435 #ifdef CONFIG_SND_PCM_XRUN_DEBUG 435 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
436 unsigned int xrun_debug; /* 0 = disabled, 1 = verbose, 2 = stacktrace */ 436 unsigned int xrun_debug; /* 0 = disabled, 1 = verbose, 2 = stacktrace */
437 struct snd_info_entry *proc_xrun_debug_entry; 437 struct snd_info_entry *proc_xrun_debug_entry;
438 #endif 438 #endif
439 #endif 439 #endif
440 }; 440 };
441 441
442 struct snd_pcm { 442 struct snd_pcm {
443 struct snd_card *card; 443 struct snd_card *card;
444 struct list_head list; 444 struct list_head list;
445 int device; /* device number */ 445 int device; /* device number */
446 unsigned int info_flags; 446 unsigned int info_flags;
447 unsigned short dev_class; 447 unsigned short dev_class;
448 unsigned short dev_subclass; 448 unsigned short dev_subclass;
449 char id[64]; 449 char id[64];
450 char name[80]; 450 char name[80];
451 struct snd_pcm_str streams[2]; 451 struct snd_pcm_str streams[2];
452 struct mutex open_mutex; 452 struct mutex open_mutex;
453 wait_queue_head_t open_wait; 453 wait_queue_head_t open_wait;
454 void *private_data; 454 void *private_data;
455 void (*private_free) (struct snd_pcm *pcm); 455 void (*private_free) (struct snd_pcm *pcm);
456 struct device *dev; /* actual hw device this belongs to */ 456 struct device *dev; /* actual hw device this belongs to */
457 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) 457 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
458 struct snd_pcm_oss oss; 458 struct snd_pcm_oss oss;
459 #endif 459 #endif
460 }; 460 };
461 461
462 struct snd_pcm_notify { 462 struct snd_pcm_notify {
463 int (*n_register) (struct snd_pcm * pcm); 463 int (*n_register) (struct snd_pcm * pcm);
464 int (*n_disconnect) (struct snd_pcm * pcm); 464 int (*n_disconnect) (struct snd_pcm * pcm);
465 int (*n_unregister) (struct snd_pcm * pcm); 465 int (*n_unregister) (struct snd_pcm * pcm);
466 struct list_head list; 466 struct list_head list;
467 }; 467 };
468 468
469 /* 469 /*
470 * Registering 470 * Registering
471 */ 471 */
472 472
473 extern const struct file_operations snd_pcm_f_ops[2]; 473 extern const struct file_operations snd_pcm_f_ops[2];
474 474
475 int snd_pcm_new(struct snd_card *card, const char *id, int device, 475 int snd_pcm_new(struct snd_card *card, const char *id, int device,
476 int playback_count, int capture_count, 476 int playback_count, int capture_count,
477 struct snd_pcm **rpcm); 477 struct snd_pcm **rpcm);
478 int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count); 478 int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count);
479 479
480 int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree); 480 int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree);
481 481
482 /* 482 /*
483 * Native I/O 483 * Native I/O
484 */ 484 */
485 485
486 extern rwlock_t snd_pcm_link_rwlock; 486 extern rwlock_t snd_pcm_link_rwlock;
487 487
488 int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info); 488 int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info);
489 int snd_pcm_info_user(struct snd_pcm_substream *substream, 489 int snd_pcm_info_user(struct snd_pcm_substream *substream,
490 struct snd_pcm_info __user *info); 490 struct snd_pcm_info __user *info);
491 int snd_pcm_status(struct snd_pcm_substream *substream, 491 int snd_pcm_status(struct snd_pcm_substream *substream,
492 struct snd_pcm_status *status); 492 struct snd_pcm_status *status);
493 int snd_pcm_start(struct snd_pcm_substream *substream); 493 int snd_pcm_start(struct snd_pcm_substream *substream);
494 int snd_pcm_stop(struct snd_pcm_substream *substream, snd_pcm_state_t status); 494 int snd_pcm_stop(struct snd_pcm_substream *substream, snd_pcm_state_t status);
495 int snd_pcm_drain_done(struct snd_pcm_substream *substream); 495 int snd_pcm_drain_done(struct snd_pcm_substream *substream);
496 #ifdef CONFIG_PM 496 #ifdef CONFIG_PM
497 int snd_pcm_suspend(struct snd_pcm_substream *substream); 497 int snd_pcm_suspend(struct snd_pcm_substream *substream);
498 int snd_pcm_suspend_all(struct snd_pcm *pcm); 498 int snd_pcm_suspend_all(struct snd_pcm *pcm);
499 #endif 499 #endif
500 int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg); 500 int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg);
501 int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, struct file *file, 501 int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, struct file *file,
502 struct snd_pcm_substream **rsubstream); 502 struct snd_pcm_substream **rsubstream);
503 void snd_pcm_release_substream(struct snd_pcm_substream *substream); 503 void snd_pcm_release_substream(struct snd_pcm_substream *substream);
504 int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream, struct file *file, 504 int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream, struct file *file,
505 struct snd_pcm_substream **rsubstream); 505 struct snd_pcm_substream **rsubstream);
506 void snd_pcm_detach_substream(struct snd_pcm_substream *substream); 506 void snd_pcm_detach_substream(struct snd_pcm_substream *substream);
507 void snd_pcm_vma_notify_data(void *client, void *data); 507 void snd_pcm_vma_notify_data(void *client, void *data);
508 int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area); 508 int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area);
509 509
510 510
511 #ifdef CONFIG_SND_DEBUG 511 #ifdef CONFIG_SND_DEBUG
512 void snd_pcm_debug_name(struct snd_pcm_substream *substream, 512 void snd_pcm_debug_name(struct snd_pcm_substream *substream,
513 char *name, size_t len); 513 char *name, size_t len);
514 #else 514 #else
515 static inline void 515 static inline void
516 snd_pcm_debug_name(struct snd_pcm_substream *substream, char *buf, size_t size) 516 snd_pcm_debug_name(struct snd_pcm_substream *substream, char *buf, size_t size)
517 { 517 {
518 *buf = 0; 518 *buf = 0;
519 } 519 }
520 #endif 520 #endif
521 521
522 /* 522 /*
523 * PCM library 523 * PCM library
524 */ 524 */
525 525
526 static inline int snd_pcm_stream_linked(struct snd_pcm_substream *substream) 526 static inline int snd_pcm_stream_linked(struct snd_pcm_substream *substream)
527 { 527 {
528 return substream->group != &substream->self_group; 528 return substream->group != &substream->self_group;
529 } 529 }
530 530
531 static inline void snd_pcm_stream_lock(struct snd_pcm_substream *substream) 531 static inline void snd_pcm_stream_lock(struct snd_pcm_substream *substream)
532 { 532 {
533 read_lock(&snd_pcm_link_rwlock); 533 read_lock(&snd_pcm_link_rwlock);
534 spin_lock(&substream->self_group.lock); 534 spin_lock(&substream->self_group.lock);
535 } 535 }
536 536
537 static inline void snd_pcm_stream_unlock(struct snd_pcm_substream *substream) 537 static inline void snd_pcm_stream_unlock(struct snd_pcm_substream *substream)
538 { 538 {
539 spin_unlock(&substream->self_group.lock); 539 spin_unlock(&substream->self_group.lock);
540 read_unlock(&snd_pcm_link_rwlock); 540 read_unlock(&snd_pcm_link_rwlock);
541 } 541 }
542 542
543 static inline void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream) 543 static inline void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream)
544 { 544 {
545 read_lock_irq(&snd_pcm_link_rwlock); 545 read_lock_irq(&snd_pcm_link_rwlock);
546 spin_lock(&substream->self_group.lock); 546 spin_lock(&substream->self_group.lock);
547 } 547 }
548 548
549 static inline void snd_pcm_stream_unlock_irq(struct snd_pcm_substream *substream) 549 static inline void snd_pcm_stream_unlock_irq(struct snd_pcm_substream *substream)
550 { 550 {
551 spin_unlock(&substream->self_group.lock); 551 spin_unlock(&substream->self_group.lock);
552 read_unlock_irq(&snd_pcm_link_rwlock); 552 read_unlock_irq(&snd_pcm_link_rwlock);
553 } 553 }
554 554
555 #define snd_pcm_stream_lock_irqsave(substream, flags) \ 555 #define snd_pcm_stream_lock_irqsave(substream, flags) \
556 do { \ 556 do { \
557 read_lock_irqsave(&snd_pcm_link_rwlock, (flags)); \ 557 read_lock_irqsave(&snd_pcm_link_rwlock, (flags)); \
558 spin_lock(&substream->self_group.lock); \ 558 spin_lock(&substream->self_group.lock); \
559 } while (0) 559 } while (0)
560 560
561 #define snd_pcm_stream_unlock_irqrestore(substream, flags) \ 561 #define snd_pcm_stream_unlock_irqrestore(substream, flags) \
562 do { \ 562 do { \
563 spin_unlock(&substream->self_group.lock); \ 563 spin_unlock(&substream->self_group.lock); \
564 read_unlock_irqrestore(&snd_pcm_link_rwlock, (flags)); \ 564 read_unlock_irqrestore(&snd_pcm_link_rwlock, (flags)); \
565 } while (0) 565 } while (0)
566 566
567 #define snd_pcm_group_for_each_entry(s, substream) \ 567 #define snd_pcm_group_for_each_entry(s, substream) \
568 list_for_each_entry(s, &substream->group->substreams, link_list) 568 list_for_each_entry(s, &substream->group->substreams, link_list)
569 569
570 static inline int snd_pcm_running(struct snd_pcm_substream *substream) 570 static inline int snd_pcm_running(struct snd_pcm_substream *substream)
571 { 571 {
572 return (substream->runtime->status->state == SNDRV_PCM_STATE_RUNNING || 572 return (substream->runtime->status->state == SNDRV_PCM_STATE_RUNNING ||
573 (substream->runtime->status->state == SNDRV_PCM_STATE_DRAINING && 573 (substream->runtime->status->state == SNDRV_PCM_STATE_DRAINING &&
574 substream->stream == SNDRV_PCM_STREAM_PLAYBACK)); 574 substream->stream == SNDRV_PCM_STREAM_PLAYBACK));
575 } 575 }
576 576
577 static inline ssize_t bytes_to_samples(struct snd_pcm_runtime *runtime, ssize_t size) 577 static inline ssize_t bytes_to_samples(struct snd_pcm_runtime *runtime, ssize_t size)
578 { 578 {
579 return size * 8 / runtime->sample_bits; 579 return size * 8 / runtime->sample_bits;
580 } 580 }
581 581
582 static inline snd_pcm_sframes_t bytes_to_frames(struct snd_pcm_runtime *runtime, ssize_t size) 582 static inline snd_pcm_sframes_t bytes_to_frames(struct snd_pcm_runtime *runtime, ssize_t size)
583 { 583 {
584 return size * 8 / runtime->frame_bits; 584 return size * 8 / runtime->frame_bits;
585 } 585 }
586 586
587 static inline ssize_t samples_to_bytes(struct snd_pcm_runtime *runtime, ssize_t size) 587 static inline ssize_t samples_to_bytes(struct snd_pcm_runtime *runtime, ssize_t size)
588 { 588 {
589 return size * runtime->sample_bits / 8; 589 return size * runtime->sample_bits / 8;
590 } 590 }
591 591
592 static inline ssize_t frames_to_bytes(struct snd_pcm_runtime *runtime, snd_pcm_sframes_t size) 592 static inline ssize_t frames_to_bytes(struct snd_pcm_runtime *runtime, snd_pcm_sframes_t size)
593 { 593 {
594 return size * runtime->frame_bits / 8; 594 return size * runtime->frame_bits / 8;
595 } 595 }
596 596
597 static inline int frame_aligned(struct snd_pcm_runtime *runtime, ssize_t bytes) 597 static inline int frame_aligned(struct snd_pcm_runtime *runtime, ssize_t bytes)
598 { 598 {
599 return bytes % runtime->byte_align == 0; 599 return bytes % runtime->byte_align == 0;
600 } 600 }
601 601
602 static inline size_t snd_pcm_lib_buffer_bytes(struct snd_pcm_substream *substream) 602 static inline size_t snd_pcm_lib_buffer_bytes(struct snd_pcm_substream *substream)
603 { 603 {
604 struct snd_pcm_runtime *runtime = substream->runtime; 604 struct snd_pcm_runtime *runtime = substream->runtime;
605 return frames_to_bytes(runtime, runtime->buffer_size); 605 return frames_to_bytes(runtime, runtime->buffer_size);
606 } 606 }
607 607
608 static inline size_t snd_pcm_lib_period_bytes(struct snd_pcm_substream *substream) 608 static inline size_t snd_pcm_lib_period_bytes(struct snd_pcm_substream *substream)
609 { 609 {
610 struct snd_pcm_runtime *runtime = substream->runtime; 610 struct snd_pcm_runtime *runtime = substream->runtime;
611 return frames_to_bytes(runtime, runtime->period_size); 611 return frames_to_bytes(runtime, runtime->period_size);
612 } 612 }
613 613
614 /* 614 /*
615 * result is: 0 ... (boundary - 1) 615 * result is: 0 ... (boundary - 1)
616 */ 616 */
617 static inline snd_pcm_uframes_t snd_pcm_playback_avail(struct snd_pcm_runtime *runtime) 617 static inline snd_pcm_uframes_t snd_pcm_playback_avail(struct snd_pcm_runtime *runtime)
618 { 618 {
619 snd_pcm_sframes_t avail = runtime->status->hw_ptr + runtime->buffer_size - runtime->control->appl_ptr; 619 snd_pcm_sframes_t avail = runtime->status->hw_ptr + runtime->buffer_size - runtime->control->appl_ptr;
620 if (avail < 0) 620 if (avail < 0)
621 avail += runtime->boundary; 621 avail += runtime->boundary;
622 else if ((snd_pcm_uframes_t) avail >= runtime->boundary) 622 else if ((snd_pcm_uframes_t) avail >= runtime->boundary)
623 avail -= runtime->boundary; 623 avail -= runtime->boundary;
624 return avail; 624 return avail;
625 } 625 }
626 626
627 /* 627 /*
628 * result is: 0 ... (boundary - 1) 628 * result is: 0 ... (boundary - 1)
629 */ 629 */
630 static inline snd_pcm_uframes_t snd_pcm_capture_avail(struct snd_pcm_runtime *runtime) 630 static inline snd_pcm_uframes_t snd_pcm_capture_avail(struct snd_pcm_runtime *runtime)
631 { 631 {
632 snd_pcm_sframes_t avail = runtime->status->hw_ptr - runtime->control->appl_ptr; 632 snd_pcm_sframes_t avail = runtime->status->hw_ptr - runtime->control->appl_ptr;
633 if (avail < 0) 633 if (avail < 0)
634 avail += runtime->boundary; 634 avail += runtime->boundary;
635 return avail; 635 return avail;
636 } 636 }
637 637
638 static inline snd_pcm_sframes_t snd_pcm_playback_hw_avail(struct snd_pcm_runtime *runtime) 638 static inline snd_pcm_sframes_t snd_pcm_playback_hw_avail(struct snd_pcm_runtime *runtime)
639 { 639 {
640 return runtime->buffer_size - snd_pcm_playback_avail(runtime); 640 return runtime->buffer_size - snd_pcm_playback_avail(runtime);
641 } 641 }
642 642
643 static inline snd_pcm_sframes_t snd_pcm_capture_hw_avail(struct snd_pcm_runtime *runtime) 643 static inline snd_pcm_sframes_t snd_pcm_capture_hw_avail(struct snd_pcm_runtime *runtime)
644 { 644 {
645 return runtime->buffer_size - snd_pcm_capture_avail(runtime); 645 return runtime->buffer_size - snd_pcm_capture_avail(runtime);
646 } 646 }
647 647
648 /** 648 /**
649 * snd_pcm_playback_ready - check whether the playback buffer is available 649 * snd_pcm_playback_ready - check whether the playback buffer is available
650 * @substream: the pcm substream instance 650 * @substream: the pcm substream instance
651 * 651 *
652 * Checks whether enough free space is available on the playback buffer. 652 * Checks whether enough free space is available on the playback buffer.
653 * 653 *
654 * Returns non-zero if available, or zero if not. 654 * Returns non-zero if available, or zero if not.
655 */ 655 */
656 static inline int snd_pcm_playback_ready(struct snd_pcm_substream *substream) 656 static inline int snd_pcm_playback_ready(struct snd_pcm_substream *substream)
657 { 657 {
658 struct snd_pcm_runtime *runtime = substream->runtime; 658 struct snd_pcm_runtime *runtime = substream->runtime;
659 return snd_pcm_playback_avail(runtime) >= runtime->control->avail_min; 659 return snd_pcm_playback_avail(runtime) >= runtime->control->avail_min;
660 } 660 }
661 661
662 /** 662 /**
663 * snd_pcm_capture_ready - check whether the capture buffer is available 663 * snd_pcm_capture_ready - check whether the capture buffer is available
664 * @substream: the pcm substream instance 664 * @substream: the pcm substream instance
665 * 665 *
666 * Checks whether enough capture data is available on the capture buffer. 666 * Checks whether enough capture data is available on the capture buffer.
667 * 667 *
668 * Returns non-zero if available, or zero if not. 668 * Returns non-zero if available, or zero if not.
669 */ 669 */
670 static inline int snd_pcm_capture_ready(struct snd_pcm_substream *substream) 670 static inline int snd_pcm_capture_ready(struct snd_pcm_substream *substream)
671 { 671 {
672 struct snd_pcm_runtime *runtime = substream->runtime; 672 struct snd_pcm_runtime *runtime = substream->runtime;
673 return snd_pcm_capture_avail(runtime) >= runtime->control->avail_min; 673 return snd_pcm_capture_avail(runtime) >= runtime->control->avail_min;
674 } 674 }
675 675
676 /** 676 /**
677 * snd_pcm_playback_data - check whether any data exists on the playback buffer 677 * snd_pcm_playback_data - check whether any data exists on the playback buffer
678 * @substream: the pcm substream instance 678 * @substream: the pcm substream instance
679 * 679 *
680 * Checks whether any data exists on the playback buffer. If stop_threshold 680 * Checks whether any data exists on the playback buffer. If stop_threshold
681 * is bigger or equal to boundary, then this function returns always non-zero. 681 * is bigger or equal to boundary, then this function returns always non-zero.
682 * 682 *
683 * Returns non-zero if exists, or zero if not. 683 * Returns non-zero if exists, or zero if not.
684 */ 684 */
685 static inline int snd_pcm_playback_data(struct snd_pcm_substream *substream) 685 static inline int snd_pcm_playback_data(struct snd_pcm_substream *substream)
686 { 686 {
687 struct snd_pcm_runtime *runtime = substream->runtime; 687 struct snd_pcm_runtime *runtime = substream->runtime;
688 688
689 if (runtime->stop_threshold >= runtime->boundary) 689 if (runtime->stop_threshold >= runtime->boundary)
690 return 1; 690 return 1;
691 return snd_pcm_playback_avail(runtime) < runtime->buffer_size; 691 return snd_pcm_playback_avail(runtime) < runtime->buffer_size;
692 } 692 }
693 693
694 /** 694 /**
695 * snd_pcm_playback_empty - check whether the playback buffer is empty 695 * snd_pcm_playback_empty - check whether the playback buffer is empty
696 * @substream: the pcm substream instance 696 * @substream: the pcm substream instance
697 * 697 *
698 * Checks whether the playback buffer is empty. 698 * Checks whether the playback buffer is empty.
699 * 699 *
700 * Returns non-zero if empty, or zero if not. 700 * Returns non-zero if empty, or zero if not.
701 */ 701 */
702 static inline int snd_pcm_playback_empty(struct snd_pcm_substream *substream) 702 static inline int snd_pcm_playback_empty(struct snd_pcm_substream *substream)
703 { 703 {
704 struct snd_pcm_runtime *runtime = substream->runtime; 704 struct snd_pcm_runtime *runtime = substream->runtime;
705 return snd_pcm_playback_avail(runtime) >= runtime->buffer_size; 705 return snd_pcm_playback_avail(runtime) >= runtime->buffer_size;
706 } 706 }
707 707
708 /** 708 /**
709 * snd_pcm_capture_empty - check whether the capture buffer is empty 709 * snd_pcm_capture_empty - check whether the capture buffer is empty
710 * @substream: the pcm substream instance 710 * @substream: the pcm substream instance
711 * 711 *
712 * Checks whether the capture buffer is empty. 712 * Checks whether the capture buffer is empty.
713 * 713 *
714 * Returns non-zero if empty, or zero if not. 714 * Returns non-zero if empty, or zero if not.
715 */ 715 */
716 static inline int snd_pcm_capture_empty(struct snd_pcm_substream *substream) 716 static inline int snd_pcm_capture_empty(struct snd_pcm_substream *substream)
717 { 717 {
718 struct snd_pcm_runtime *runtime = substream->runtime; 718 struct snd_pcm_runtime *runtime = substream->runtime;
719 return snd_pcm_capture_avail(runtime) == 0; 719 return snd_pcm_capture_avail(runtime) == 0;
720 } 720 }
721 721
722 static inline void snd_pcm_trigger_done(struct snd_pcm_substream *substream, 722 static inline void snd_pcm_trigger_done(struct snd_pcm_substream *substream,
723 struct snd_pcm_substream *master) 723 struct snd_pcm_substream *master)
724 { 724 {
725 substream->runtime->trigger_master = master; 725 substream->runtime->trigger_master = master;
726 } 726 }
727 727
728 static inline int hw_is_mask(int var) 728 static inline int hw_is_mask(int var)
729 { 729 {
730 return var >= SNDRV_PCM_HW_PARAM_FIRST_MASK && 730 return var >= SNDRV_PCM_HW_PARAM_FIRST_MASK &&
731 var <= SNDRV_PCM_HW_PARAM_LAST_MASK; 731 var <= SNDRV_PCM_HW_PARAM_LAST_MASK;
732 } 732 }
733 733
734 static inline int hw_is_interval(int var) 734 static inline int hw_is_interval(int var)
735 { 735 {
736 return var >= SNDRV_PCM_HW_PARAM_FIRST_INTERVAL && 736 return var >= SNDRV_PCM_HW_PARAM_FIRST_INTERVAL &&
737 var <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; 737 var <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL;
738 } 738 }
739 739
740 static inline struct snd_mask *hw_param_mask(struct snd_pcm_hw_params *params, 740 static inline struct snd_mask *hw_param_mask(struct snd_pcm_hw_params *params,
741 snd_pcm_hw_param_t var) 741 snd_pcm_hw_param_t var)
742 { 742 {
743 return &params->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK]; 743 return &params->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK];
744 } 744 }
745 745
746 static inline struct snd_interval *hw_param_interval(struct snd_pcm_hw_params *params, 746 static inline struct snd_interval *hw_param_interval(struct snd_pcm_hw_params *params,
747 snd_pcm_hw_param_t var) 747 snd_pcm_hw_param_t var)
748 { 748 {
749 return &params->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL]; 749 return &params->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL];
750 } 750 }
751 751
752 static inline const struct snd_mask *hw_param_mask_c(const struct snd_pcm_hw_params *params, 752 static inline const struct snd_mask *hw_param_mask_c(const struct snd_pcm_hw_params *params,
753 snd_pcm_hw_param_t var) 753 snd_pcm_hw_param_t var)
754 { 754 {
755 return &params->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK]; 755 return &params->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK];
756 } 756 }
757 757
758 static inline const struct snd_interval *hw_param_interval_c(const struct snd_pcm_hw_params *params, 758 static inline const struct snd_interval *hw_param_interval_c(const struct snd_pcm_hw_params *params,
759 snd_pcm_hw_param_t var) 759 snd_pcm_hw_param_t var)
760 { 760 {
761 return &params->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL]; 761 return &params->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL];
762 } 762 }
763 763
764 #define params_channels(p) \ 764 #define params_channels(p) \
765 (hw_param_interval_c((p), SNDRV_PCM_HW_PARAM_CHANNELS)->min) 765 (hw_param_interval_c((p), SNDRV_PCM_HW_PARAM_CHANNELS)->min)
766 #define params_rate(p) \ 766 #define params_rate(p) \
767 (hw_param_interval_c((p), SNDRV_PCM_HW_PARAM_RATE)->min) 767 (hw_param_interval_c((p), SNDRV_PCM_HW_PARAM_RATE)->min)
768 #define params_period_size(p) \ 768 #define params_period_size(p) \
769 (hw_param_interval_c((p), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->min) 769 (hw_param_interval_c((p), SNDRV_PCM_HW_PARAM_PERIOD_SIZE)->min)
770 #define params_periods(p) \ 770 #define params_periods(p) \
771 (hw_param_interval_c((p), SNDRV_PCM_HW_PARAM_PERIODS)->min) 771 (hw_param_interval_c((p), SNDRV_PCM_HW_PARAM_PERIODS)->min)
772 #define params_buffer_size(p) \ 772 #define params_buffer_size(p) \
773 (hw_param_interval_c((p), SNDRV_PCM_HW_PARAM_BUFFER_SIZE)->min) 773 (hw_param_interval_c((p), SNDRV_PCM_HW_PARAM_BUFFER_SIZE)->min)
774 #define params_buffer_bytes(p) \ 774 #define params_buffer_bytes(p) \
775 (hw_param_interval_c((p), SNDRV_PCM_HW_PARAM_BUFFER_BYTES)->min) 775 (hw_param_interval_c((p), SNDRV_PCM_HW_PARAM_BUFFER_BYTES)->min)
776 776
777 int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v); 777 int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v);
778 void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c); 778 void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c);
779 void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c); 779 void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c);
780 void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b, 780 void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b,
781 unsigned int k, struct snd_interval *c); 781 unsigned int k, struct snd_interval *c);
782 void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k, 782 void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k,
783 const struct snd_interval *b, struct snd_interval *c); 783 const struct snd_interval *b, struct snd_interval *c);
784 int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int *list, unsigned int mask); 784 int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int *list, unsigned int mask);
785 int snd_interval_ratnum(struct snd_interval *i, 785 int snd_interval_ratnum(struct snd_interval *i,
786 unsigned int rats_count, struct snd_ratnum *rats, 786 unsigned int rats_count, struct snd_ratnum *rats,
787 unsigned int *nump, unsigned int *denp); 787 unsigned int *nump, unsigned int *denp);
788 788
789 void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params); 789 void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params);
790 void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var); 790 void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var);
791 int snd_pcm_hw_params_choose(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params); 791 int snd_pcm_hw_params_choose(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params);
792 792
793 int snd_pcm_hw_refine(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params); 793 int snd_pcm_hw_refine(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params);
794 794
795 int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream); 795 int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream);
796 int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream); 796 int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream);
797 797
798 int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, 798 int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
799 u_int32_t mask); 799 u_int32_t mask);
800 int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, 800 int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
801 u_int64_t mask); 801 u_int64_t mask);
802 int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, 802 int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var,
803 unsigned int min, unsigned int max); 803 unsigned int min, unsigned int max);
804 int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var); 804 int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var);
805 int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime, 805 int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime,
806 unsigned int cond, 806 unsigned int cond,
807 snd_pcm_hw_param_t var, 807 snd_pcm_hw_param_t var,
808 struct snd_pcm_hw_constraint_list *l); 808 struct snd_pcm_hw_constraint_list *l);
809 int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime, 809 int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime,
810 unsigned int cond, 810 unsigned int cond,
811 snd_pcm_hw_param_t var, 811 snd_pcm_hw_param_t var,
812 struct snd_pcm_hw_constraint_ratnums *r); 812 struct snd_pcm_hw_constraint_ratnums *r);
813 int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime, 813 int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime,
814 unsigned int cond, 814 unsigned int cond,
815 snd_pcm_hw_param_t var, 815 snd_pcm_hw_param_t var,
816 struct snd_pcm_hw_constraint_ratdens *r); 816 struct snd_pcm_hw_constraint_ratdens *r);
817 int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, 817 int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime,
818 unsigned int cond, 818 unsigned int cond,
819 unsigned int width, 819 unsigned int width,
820 unsigned int msbits); 820 unsigned int msbits);
821 int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime, 821 int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime,
822 unsigned int cond, 822 unsigned int cond,
823 snd_pcm_hw_param_t var, 823 snd_pcm_hw_param_t var,
824 unsigned long step); 824 unsigned long step);
825 int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime, 825 int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime,
826 unsigned int cond, 826 unsigned int cond,
827 snd_pcm_hw_param_t var); 827 snd_pcm_hw_param_t var);
828 int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, 828 int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime,
829 unsigned int cond, 829 unsigned int cond,
830 int var, 830 int var,
831 snd_pcm_hw_rule_func_t func, void *private, 831 snd_pcm_hw_rule_func_t func, void *private,
832 int dep, ...); 832 int dep, ...);
833 833
834 int snd_pcm_format_signed(snd_pcm_format_t format); 834 int snd_pcm_format_signed(snd_pcm_format_t format);
835 int snd_pcm_format_unsigned(snd_pcm_format_t format); 835 int snd_pcm_format_unsigned(snd_pcm_format_t format);
836 int snd_pcm_format_linear(snd_pcm_format_t format); 836 int snd_pcm_format_linear(snd_pcm_format_t format);
837 int snd_pcm_format_little_endian(snd_pcm_format_t format); 837 int snd_pcm_format_little_endian(snd_pcm_format_t format);
838 int snd_pcm_format_big_endian(snd_pcm_format_t format); 838 int snd_pcm_format_big_endian(snd_pcm_format_t format);
839 #if 0 /* just for DocBook */ 839 #if 0 /* just for DocBook */
840 /** 840 /**
841 * snd_pcm_format_cpu_endian - Check the PCM format is CPU-endian 841 * snd_pcm_format_cpu_endian - Check the PCM format is CPU-endian
842 * @format: the format to check 842 * @format: the format to check
843 * 843 *
844 * Returns 1 if the given PCM format is CPU-endian, 0 if 844 * Returns 1 if the given PCM format is CPU-endian, 0 if
845 * opposite, or a negative error code if endian not specified. 845 * opposite, or a negative error code if endian not specified.
846 */ 846 */
847 int snd_pcm_format_cpu_endian(snd_pcm_format_t format); 847 int snd_pcm_format_cpu_endian(snd_pcm_format_t format);
848 #endif /* DocBook */ 848 #endif /* DocBook */
849 #ifdef SNDRV_LITTLE_ENDIAN 849 #ifdef SNDRV_LITTLE_ENDIAN
850 #define snd_pcm_format_cpu_endian(format) snd_pcm_format_little_endian(format) 850 #define snd_pcm_format_cpu_endian(format) snd_pcm_format_little_endian(format)
851 #else 851 #else
852 #define snd_pcm_format_cpu_endian(format) snd_pcm_format_big_endian(format) 852 #define snd_pcm_format_cpu_endian(format) snd_pcm_format_big_endian(format)
853 #endif 853 #endif
854 int snd_pcm_format_width(snd_pcm_format_t format); /* in bits */ 854 int snd_pcm_format_width(snd_pcm_format_t format); /* in bits */
855 int snd_pcm_format_physical_width(snd_pcm_format_t format); /* in bits */ 855 int snd_pcm_format_physical_width(snd_pcm_format_t format); /* in bits */
856 ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples); 856 ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples);
857 const unsigned char *snd_pcm_format_silence_64(snd_pcm_format_t format); 857 const unsigned char *snd_pcm_format_silence_64(snd_pcm_format_t format);
858 int snd_pcm_format_set_silence(snd_pcm_format_t format, void *buf, unsigned int frames); 858 int snd_pcm_format_set_silence(snd_pcm_format_t format, void *buf, unsigned int frames);
859 snd_pcm_format_t snd_pcm_build_linear_format(int width, int unsignd, int big_endian); 859 snd_pcm_format_t snd_pcm_build_linear_format(int width, int unsignd, int big_endian);
860 860
861 void snd_pcm_set_ops(struct snd_pcm * pcm, int direction, struct snd_pcm_ops *ops); 861 void snd_pcm_set_ops(struct snd_pcm * pcm, int direction, struct snd_pcm_ops *ops);
862 void snd_pcm_set_sync(struct snd_pcm_substream *substream); 862 void snd_pcm_set_sync(struct snd_pcm_substream *substream);
863 int snd_pcm_lib_interleave_len(struct snd_pcm_substream *substream); 863 int snd_pcm_lib_interleave_len(struct snd_pcm_substream *substream);
864 int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream, 864 int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,
865 unsigned int cmd, void *arg); 865 unsigned int cmd, void *arg);
866 int snd_pcm_update_state(struct snd_pcm_substream *substream, 866 int snd_pcm_update_state(struct snd_pcm_substream *substream,
867 struct snd_pcm_runtime *runtime); 867 struct snd_pcm_runtime *runtime);
868 int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream); 868 int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream);
869 int snd_pcm_playback_xrun_check(struct snd_pcm_substream *substream); 869 int snd_pcm_playback_xrun_check(struct snd_pcm_substream *substream);
870 int snd_pcm_capture_xrun_check(struct snd_pcm_substream *substream); 870 int snd_pcm_capture_xrun_check(struct snd_pcm_substream *substream);
871 int snd_pcm_playback_xrun_asap(struct snd_pcm_substream *substream); 871 int snd_pcm_playback_xrun_asap(struct snd_pcm_substream *substream);
872 int snd_pcm_capture_xrun_asap(struct snd_pcm_substream *substream); 872 int snd_pcm_capture_xrun_asap(struct snd_pcm_substream *substream);
873 void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr); 873 void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr);
874 void snd_pcm_period_elapsed(struct snd_pcm_substream *substream); 874 void snd_pcm_period_elapsed(struct snd_pcm_substream *substream);
875 snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, 875 snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream,
876 const void __user *buf, 876 const void __user *buf,
877 snd_pcm_uframes_t frames); 877 snd_pcm_uframes_t frames);
878 snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, 878 snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream,
879 void __user *buf, snd_pcm_uframes_t frames); 879 void __user *buf, snd_pcm_uframes_t frames);
880 snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream, 880 snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream,
881 void __user **bufs, snd_pcm_uframes_t frames); 881 void __user **bufs, snd_pcm_uframes_t frames);
882 snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream, 882 snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream,
883 void __user **bufs, snd_pcm_uframes_t frames); 883 void __user **bufs, snd_pcm_uframes_t frames);
884 884
885 extern const struct snd_pcm_hw_constraint_list snd_pcm_known_rates; 885 extern const struct snd_pcm_hw_constraint_list snd_pcm_known_rates;
886 886
887 int snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime); 887 int snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime);
888 unsigned int snd_pcm_rate_to_rate_bit(unsigned int rate); 888 unsigned int snd_pcm_rate_to_rate_bit(unsigned int rate);
889 889
890 static inline void snd_pcm_set_runtime_buffer(struct snd_pcm_substream *substream, 890 static inline void snd_pcm_set_runtime_buffer(struct snd_pcm_substream *substream,
891 struct snd_dma_buffer *bufp) 891 struct snd_dma_buffer *bufp)
892 { 892 {
893 struct snd_pcm_runtime *runtime = substream->runtime; 893 struct snd_pcm_runtime *runtime = substream->runtime;
894 if (bufp) { 894 if (bufp) {
895 runtime->dma_buffer_p = bufp; 895 runtime->dma_buffer_p = bufp;
896 runtime->dma_area = bufp->area; 896 runtime->dma_area = bufp->area;
897 runtime->dma_addr = bufp->addr; 897 runtime->dma_addr = bufp->addr;
898 runtime->dma_bytes = bufp->bytes; 898 runtime->dma_bytes = bufp->bytes;
899 } else { 899 } else {
900 runtime->dma_buffer_p = NULL; 900 runtime->dma_buffer_p = NULL;
901 runtime->dma_area = NULL; 901 runtime->dma_area = NULL;
902 runtime->dma_addr = 0; 902 runtime->dma_addr = 0;
903 runtime->dma_bytes = 0; 903 runtime->dma_bytes = 0;
904 } 904 }
905 } 905 }
906 906
907 /* 907 /*
908 * Timer interface 908 * Timer interface
909 */ 909 */
910 910
911 void snd_pcm_timer_resolution_change(struct snd_pcm_substream *substream); 911 void snd_pcm_timer_resolution_change(struct snd_pcm_substream *substream);
912 void snd_pcm_timer_init(struct snd_pcm_substream *substream); 912 void snd_pcm_timer_init(struct snd_pcm_substream *substream);
913 void snd_pcm_timer_done(struct snd_pcm_substream *substream); 913 void snd_pcm_timer_done(struct snd_pcm_substream *substream);
914 914
915 static inline void snd_pcm_gettime(struct snd_pcm_runtime *runtime, 915 static inline void snd_pcm_gettime(struct snd_pcm_runtime *runtime,
916 struct timespec *tv) 916 struct timespec *tv)
917 { 917 {
918 if (runtime->tstamp_type == SNDRV_PCM_TSTAMP_TYPE_MONOTONIC) 918 if (runtime->tstamp_type == SNDRV_PCM_TSTAMP_TYPE_MONOTONIC)
919 do_posix_clock_monotonic_gettime(tv); 919 do_posix_clock_monotonic_gettime(tv);
920 else 920 else
921 getnstimeofday(tv); 921 getnstimeofday(tv);
922 } 922 }
923 923
924 /* 924 /*
925 * Memory 925 * Memory
926 */ 926 */
927 927
928 int snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream); 928 int snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream);
929 int snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm); 929 int snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm);
930 int snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream, 930 int snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream,
931 int type, struct device *data, 931 int type, struct device *data,
932 size_t size, size_t max); 932 size_t size, size_t max);
933 int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm, 933 int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm,
934 int type, void *data, 934 int type, void *data,
935 size_t size, size_t max); 935 size_t size, size_t max);
936 int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size); 936 int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size);
937 int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream); 937 int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream);
938 938
939 int _snd_pcm_lib_alloc_vmalloc_buffer(struct snd_pcm_substream *substream, 939 int _snd_pcm_lib_alloc_vmalloc_buffer(struct snd_pcm_substream *substream,
940 size_t size, gfp_t gfp_flags); 940 size_t size, gfp_t gfp_flags);
941 int snd_pcm_lib_free_vmalloc_buffer(struct snd_pcm_substream *substream); 941 int snd_pcm_lib_free_vmalloc_buffer(struct snd_pcm_substream *substream);
942 struct page *snd_pcm_lib_get_vmalloc_page(struct snd_pcm_substream *substream, 942 struct page *snd_pcm_lib_get_vmalloc_page(struct snd_pcm_substream *substream,
943 unsigned long offset); 943 unsigned long offset);
944 #if 0 /* for kernel-doc */ 944 #if 0 /* for kernel-doc */
945 /** 945 /**
946 * snd_pcm_lib_alloc_vmalloc_buffer - allocate virtual DMA buffer 946 * snd_pcm_lib_alloc_vmalloc_buffer - allocate virtual DMA buffer
947 * @substream: the substream to allocate the buffer to 947 * @substream: the substream to allocate the buffer to
948 * @size: the requested buffer size, in bytes 948 * @size: the requested buffer size, in bytes
949 * 949 *
950 * Allocates the PCM substream buffer using vmalloc(), i.e., the memory is 950 * Allocates the PCM substream buffer using vmalloc(), i.e., the memory is
951 * contiguous in kernel virtual space, but not in physical memory. Use this 951 * contiguous in kernel virtual space, but not in physical memory. Use this
952 * if the buffer is accessed by kernel code but not by device DMA. 952 * if the buffer is accessed by kernel code but not by device DMA.
953 * 953 *
954 * Returns 1 if the buffer was changed, 0 if not changed, or a negative error 954 * Returns 1 if the buffer was changed, 0 if not changed, or a negative error
955 * code. 955 * code.
956 */ 956 */
957 static int snd_pcm_lib_alloc_vmalloc_buffer 957 static int snd_pcm_lib_alloc_vmalloc_buffer
958 (struct snd_pcm_substream *substream, size_t size); 958 (struct snd_pcm_substream *substream, size_t size);
959 /** 959 /**
960 * snd_pcm_lib_alloc_vmalloc_32_buffer - allocate 32-bit-addressable buffer 960 * snd_pcm_lib_alloc_vmalloc_32_buffer - allocate 32-bit-addressable buffer
961 * @substream: the substream to allocate the buffer to 961 * @substream: the substream to allocate the buffer to
962 * @size: the requested buffer size, in bytes 962 * @size: the requested buffer size, in bytes
963 * 963 *
964 * This function works like snd_pcm_lib_alloc_vmalloc_buffer(), but uses 964 * This function works like snd_pcm_lib_alloc_vmalloc_buffer(), but uses
965 * vmalloc_32(), i.e., the pages are allocated from 32-bit-addressable memory. 965 * vmalloc_32(), i.e., the pages are allocated from 32-bit-addressable memory.
966 */ 966 */
967 static int snd_pcm_lib_alloc_vmalloc_32_buffer 967 static int snd_pcm_lib_alloc_vmalloc_32_buffer
968 (struct snd_pcm_substream *substream, size_t size); 968 (struct snd_pcm_substream *substream, size_t size);
969 #endif 969 #endif
970 #define snd_pcm_lib_alloc_vmalloc_buffer(subs, size) \ 970 #define snd_pcm_lib_alloc_vmalloc_buffer(subs, size) \
971 _snd_pcm_lib_alloc_vmalloc_buffer \ 971 _snd_pcm_lib_alloc_vmalloc_buffer \
972 (subs, size, GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO) 972 (subs, size, GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO)
973 #define snd_pcm_lib_alloc_vmalloc_32_buffer(subs, size) \ 973 #define snd_pcm_lib_alloc_vmalloc_32_buffer(subs, size) \
974 _snd_pcm_lib_alloc_vmalloc_buffer \ 974 _snd_pcm_lib_alloc_vmalloc_buffer \
975 (subs, size, GFP_KERNEL | GFP_DMA32 | __GFP_ZERO) 975 (subs, size, GFP_KERNEL | GFP_DMA32 | __GFP_ZERO)
976 976
977 #ifdef CONFIG_SND_DMA_SGBUF 977 #ifdef CONFIG_SND_DMA_SGBUF
978 /* 978 /*
979 * SG-buffer handling 979 * SG-buffer handling
980 */ 980 */
981 #define snd_pcm_substream_sgbuf(substream) \ 981 #define snd_pcm_substream_sgbuf(substream) \
982 ((substream)->runtime->dma_buffer_p->private_data) 982 ((substream)->runtime->dma_buffer_p->private_data)
983 983
984 static inline dma_addr_t 984 static inline dma_addr_t
985 snd_pcm_sgbuf_get_addr(struct snd_pcm_substream *substream, unsigned int ofs) 985 snd_pcm_sgbuf_get_addr(struct snd_pcm_substream *substream, unsigned int ofs)
986 { 986 {
987 struct snd_sg_buf *sg = snd_pcm_substream_sgbuf(substream); 987 struct snd_sg_buf *sg = snd_pcm_substream_sgbuf(substream);
988 return snd_sgbuf_get_addr(sg, ofs); 988 return snd_sgbuf_get_addr(sg, ofs);
989 } 989 }
990 990
991 static inline void * 991 static inline void *
992 snd_pcm_sgbuf_get_ptr(struct snd_pcm_substream *substream, unsigned int ofs) 992 snd_pcm_sgbuf_get_ptr(struct snd_pcm_substream *substream, unsigned int ofs)
993 { 993 {
994 struct snd_sg_buf *sg = snd_pcm_substream_sgbuf(substream); 994 struct snd_sg_buf *sg = snd_pcm_substream_sgbuf(substream);
995 return snd_sgbuf_get_ptr(sg, ofs); 995 return snd_sgbuf_get_ptr(sg, ofs);
996 } 996 }
997 997
998 struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream, 998 struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream,
999 unsigned long offset); 999 unsigned long offset);
1000 unsigned int snd_pcm_sgbuf_get_chunk_size(struct snd_pcm_substream *substream, 1000 unsigned int snd_pcm_sgbuf_get_chunk_size(struct snd_pcm_substream *substream,
1001 unsigned int ofs, unsigned int size); 1001 unsigned int ofs, unsigned int size);
1002 1002
1003 #else /* !SND_DMA_SGBUF */ 1003 #else /* !SND_DMA_SGBUF */
1004 /* 1004 /*
1005 * fake using a continuous buffer 1005 * fake using a continuous buffer
1006 */ 1006 */
1007 static inline dma_addr_t 1007 static inline dma_addr_t
1008 snd_pcm_sgbuf_get_addr(struct snd_pcm_substream *substream, unsigned int ofs) 1008 snd_pcm_sgbuf_get_addr(struct snd_pcm_substream *substream, unsigned int ofs)
1009 { 1009 {
1010 return substream->runtime->dma_addr + ofs; 1010 return substream->runtime->dma_addr + ofs;
1011 } 1011 }
1012 1012
1013 static inline void * 1013 static inline void *
1014 snd_pcm_sgbuf_get_ptr(struct snd_pcm_substream *substream, unsigned int ofs) 1014 snd_pcm_sgbuf_get_ptr(struct snd_pcm_substream *substream, unsigned int ofs)
1015 { 1015 {
1016 return substream->runtime->dma_area + ofs; 1016 return substream->runtime->dma_area + ofs;
1017 } 1017 }
1018 1018
1019 #define snd_pcm_sgbuf_ops_page NULL 1019 #define snd_pcm_sgbuf_ops_page NULL
1020 1020
1021 #define snd_pcm_sgbuf_get_chunk_size(subs, ofs, size) (size) 1021 #define snd_pcm_sgbuf_get_chunk_size(subs, ofs, size) (size)
1022 1022
1023 #endif /* SND_DMA_SGBUF */ 1023 #endif /* SND_DMA_SGBUF */
1024 1024
1025 /* handle mmap counter - PCM mmap callback should handle this counter properly */ 1025 /* handle mmap counter - PCM mmap callback should handle this counter properly */
1026 static inline void snd_pcm_mmap_data_open(struct vm_area_struct *area) 1026 static inline void snd_pcm_mmap_data_open(struct vm_area_struct *area)
1027 { 1027 {
1028 struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data; 1028 struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data;
1029 atomic_inc(&substream->mmap_count); 1029 atomic_inc(&substream->mmap_count);
1030 } 1030 }
1031 1031
1032 static inline void snd_pcm_mmap_data_close(struct vm_area_struct *area) 1032 static inline void snd_pcm_mmap_data_close(struct vm_area_struct *area)
1033 { 1033 {
1034 struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data; 1034 struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data;
1035 atomic_dec(&substream->mmap_count); 1035 atomic_dec(&substream->mmap_count);
1036 } 1036 }
1037 1037
1038 /* mmap for io-memory area */ 1038 /* mmap for io-memory area */
1039 #if defined(CONFIG_X86) || defined(CONFIG_PPC) || defined(CONFIG_ALPHA) 1039 #if defined(CONFIG_X86) || defined(CONFIG_PPC) || defined(CONFIG_ALPHA)
1040 #define SNDRV_PCM_INFO_MMAP_IOMEM SNDRV_PCM_INFO_MMAP 1040 #define SNDRV_PCM_INFO_MMAP_IOMEM SNDRV_PCM_INFO_MMAP
1041 int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream, struct vm_area_struct *area); 1041 int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream, struct vm_area_struct *area);
1042 #else 1042 #else
1043 #define SNDRV_PCM_INFO_MMAP_IOMEM 0 1043 #define SNDRV_PCM_INFO_MMAP_IOMEM 0
1044 #define snd_pcm_lib_mmap_iomem NULL 1044 #define snd_pcm_lib_mmap_iomem NULL
1045 #endif 1045 #endif
1046 1046
1047 #define snd_pcm_lib_mmap_vmalloc NULL 1047 #define snd_pcm_lib_mmap_vmalloc NULL
1048 1048
1049 static inline void snd_pcm_limit_isa_dma_size(int dma, size_t *max) 1049 static inline void snd_pcm_limit_isa_dma_size(int dma, size_t *max)
1050 { 1050 {
1051 *max = dma < 4 ? 64 * 1024 : 128 * 1024; 1051 *max = dma < 4 ? 64 * 1024 : 128 * 1024;
1052 } 1052 }
1053 1053
1054 /* 1054 /*
1055 * Misc 1055 * Misc
1056 */ 1056 */
1057 1057
1058 #define SNDRV_PCM_DEFAULT_CON_SPDIF (IEC958_AES0_CON_EMPHASIS_NONE|\ 1058 #define SNDRV_PCM_DEFAULT_CON_SPDIF (IEC958_AES0_CON_EMPHASIS_NONE|\
1059 (IEC958_AES1_CON_ORIGINAL<<8)|\ 1059 (IEC958_AES1_CON_ORIGINAL<<8)|\
1060 (IEC958_AES1_CON_PCM_CODER<<8)|\ 1060 (IEC958_AES1_CON_PCM_CODER<<8)|\
1061 (IEC958_AES3_CON_FS_48000<<24)) 1061 (IEC958_AES3_CON_FS_48000<<24))
1062 1062
1063 #define PCM_RUNTIME_CHECK(sub) snd_BUG_ON(!(sub) || !(sub)->runtime) 1063 #define PCM_RUNTIME_CHECK(sub) snd_BUG_ON(!(sub) || !(sub)->runtime)
1064 1064
1065 const char *snd_pcm_format_name(snd_pcm_format_t format); 1065 const char *snd_pcm_format_name(snd_pcm_format_t format);
1066 1066
1067 #endif /* __SOUND_PCM_H */ 1067 #endif /* __SOUND_PCM_H */
1068 1068
1 /* 1 /*
2 * This module exposes the interface to kernel space for specifying 2 * This module exposes the interface to kernel space for specifying
3 * QoS dependencies. It provides infrastructure for registration of: 3 * QoS dependencies. It provides infrastructure for registration of:
4 * 4 *
5 * Dependents on a QoS value : register requests 5 * Dependents on a QoS value : register requests
6 * Watchers of QoS value : get notified when target QoS value changes 6 * Watchers of QoS value : get notified when target QoS value changes
7 * 7 *
8 * This QoS design is best effort based. Dependents register their QoS needs. 8 * This QoS design is best effort based. Dependents register their QoS needs.
9 * Watchers register to keep track of the current QoS needs of the system. 9 * Watchers register to keep track of the current QoS needs of the system.
10 * 10 *
11 * There are 3 basic classes of QoS parameter: latency, timeout, throughput 11 * There are 3 basic classes of QoS parameter: latency, timeout, throughput
12 * each have defined units: 12 * each have defined units:
13 * latency: usec 13 * latency: usec
14 * timeout: usec <-- currently not used. 14 * timeout: usec <-- currently not used.
15 * throughput: kbs (kilo byte / sec) 15 * throughput: kbs (kilo byte / sec)
16 * 16 *
17 * There are lists of pm_qos_objects each one wrapping requests, notifiers 17 * There are lists of pm_qos_objects each one wrapping requests, notifiers
18 * 18 *
19 * User mode requests on a QOS parameter register themselves to the 19 * User mode requests on a QOS parameter register themselves to the
20 * subsystem by opening the device node /dev/... and writing there request to 20 * subsystem by opening the device node /dev/... and writing there request to
21 * the node. As long as the process holds a file handle open to the node the 21 * the node. As long as the process holds a file handle open to the node the
22 * client continues to be accounted for. Upon file release the usermode 22 * client continues to be accounted for. Upon file release the usermode
23 * request is removed and a new qos target is computed. This way when the 23 * request is removed and a new qos target is computed. This way when the
24 * request that the application has is cleaned up when closes the file 24 * request that the application has is cleaned up when closes the file
25 * pointer or exits the pm_qos_object will get an opportunity to clean up. 25 * pointer or exits the pm_qos_object will get an opportunity to clean up.
26 * 26 *
27 * Mark Gross <mgross@linux.intel.com> 27 * Mark Gross <mgross@linux.intel.com>
28 */ 28 */
29 29
30 /*#define DEBUG*/ 30 /*#define DEBUG*/
31 31
32 #include <linux/pm_qos.h> 32 #include <linux/pm_qos.h>
33 #include <linux/sched.h> 33 #include <linux/sched.h>
34 #include <linux/spinlock.h> 34 #include <linux/spinlock.h>
35 #include <linux/slab.h> 35 #include <linux/slab.h>
36 #include <linux/time.h> 36 #include <linux/time.h>
37 #include <linux/fs.h> 37 #include <linux/fs.h>
38 #include <linux/device.h> 38 #include <linux/device.h>
39 #include <linux/miscdevice.h> 39 #include <linux/miscdevice.h>
40 #include <linux/string.h> 40 #include <linux/string.h>
41 #include <linux/platform_device.h> 41 #include <linux/platform_device.h>
42 #include <linux/init.h> 42 #include <linux/init.h>
43 #include <linux/kernel.h> 43 #include <linux/kernel.h>
44 44
45 #include <linux/uaccess.h> 45 #include <linux/uaccess.h>
46 46
47 /* 47 /*
48 * locking rule: all changes to requests or notifiers lists 48 * locking rule: all changes to constraints or notifiers lists
49 * or pm_qos_object list and pm_qos_objects need to happen with pm_qos_lock 49 * or pm_qos_object list and pm_qos_objects need to happen with pm_qos_lock
50 * held, taken with _irqsave. One lock to rule them all 50 * held, taken with _irqsave. One lock to rule them all
51 */ 51 */
52 enum pm_qos_type { 52 enum pm_qos_type {
53 PM_QOS_MAX, /* return the largest value */ 53 PM_QOS_MAX, /* return the largest value */
54 PM_QOS_MIN /* return the smallest value */ 54 PM_QOS_MIN /* return the smallest value */
55 }; 55 };
56 56
57 /* 57 /*
58 * Note: The lockless read path depends on the CPU accessing 58 * Note: The lockless read path depends on the CPU accessing
59 * target_value atomically. Atomic access is only guaranteed on all CPU 59 * target_value atomically. Atomic access is only guaranteed on all CPU
60 * types linux supports for 32 bit quantites 60 * types linux supports for 32 bit quantites
61 */ 61 */
62 struct pm_qos_object { 62 struct pm_qos_object {
63 struct plist_head requests; 63 struct plist_head constraints;
64 struct blocking_notifier_head *notifiers; 64 struct blocking_notifier_head *notifiers;
65 struct miscdevice pm_qos_power_miscdev; 65 struct miscdevice pm_qos_power_miscdev;
66 char *name; 66 char *name;
67 s32 target_value; /* Do not change to 64 bit */ 67 s32 target_value; /* Do not change to 64 bit */
68 s32 default_value; 68 s32 default_value;
69 enum pm_qos_type type; 69 enum pm_qos_type type;
70 }; 70 };
71 71
72 static DEFINE_SPINLOCK(pm_qos_lock); 72 static DEFINE_SPINLOCK(pm_qos_lock);
73 73
74 static struct pm_qos_object null_pm_qos; 74 static struct pm_qos_object null_pm_qos;
75 static BLOCKING_NOTIFIER_HEAD(cpu_dma_lat_notifier); 75 static BLOCKING_NOTIFIER_HEAD(cpu_dma_lat_notifier);
76 static struct pm_qos_object cpu_dma_pm_qos = { 76 static struct pm_qos_object cpu_dma_pm_qos = {
77 .requests = PLIST_HEAD_INIT(cpu_dma_pm_qos.requests), 77 .constraints = PLIST_HEAD_INIT(cpu_dma_pm_qos.constraints),
78 .notifiers = &cpu_dma_lat_notifier, 78 .notifiers = &cpu_dma_lat_notifier,
79 .name = "cpu_dma_latency", 79 .name = "cpu_dma_latency",
80 .target_value = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE, 80 .target_value = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE,
81 .default_value = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE, 81 .default_value = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE,
82 .type = PM_QOS_MIN, 82 .type = PM_QOS_MIN,
83 }; 83 };
84 84
85 static BLOCKING_NOTIFIER_HEAD(network_lat_notifier); 85 static BLOCKING_NOTIFIER_HEAD(network_lat_notifier);
86 static struct pm_qos_object network_lat_pm_qos = { 86 static struct pm_qos_object network_lat_pm_qos = {
87 .requests = PLIST_HEAD_INIT(network_lat_pm_qos.requests), 87 .constraints = PLIST_HEAD_INIT(network_lat_pm_qos.constraints),
88 .notifiers = &network_lat_notifier, 88 .notifiers = &network_lat_notifier,
89 .name = "network_latency", 89 .name = "network_latency",
90 .target_value = PM_QOS_NETWORK_LAT_DEFAULT_VALUE, 90 .target_value = PM_QOS_NETWORK_LAT_DEFAULT_VALUE,
91 .default_value = PM_QOS_NETWORK_LAT_DEFAULT_VALUE, 91 .default_value = PM_QOS_NETWORK_LAT_DEFAULT_VALUE,
92 .type = PM_QOS_MIN 92 .type = PM_QOS_MIN
93 }; 93 };
94 94
95 95
96 static BLOCKING_NOTIFIER_HEAD(network_throughput_notifier); 96 static BLOCKING_NOTIFIER_HEAD(network_throughput_notifier);
97 static struct pm_qos_object network_throughput_pm_qos = { 97 static struct pm_qos_object network_throughput_pm_qos = {
98 .requests = PLIST_HEAD_INIT(network_throughput_pm_qos.requests), 98 .constraints = PLIST_HEAD_INIT(network_throughput_pm_qos.constraints),
99 .notifiers = &network_throughput_notifier, 99 .notifiers = &network_throughput_notifier,
100 .name = "network_throughput", 100 .name = "network_throughput",
101 .target_value = PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE, 101 .target_value = PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE,
102 .default_value = PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE, 102 .default_value = PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE,
103 .type = PM_QOS_MAX, 103 .type = PM_QOS_MAX,
104 }; 104 };
105 105
106 106
107 static struct pm_qos_object *pm_qos_array[] = { 107 static struct pm_qos_object *pm_qos_array[] = {
108 &null_pm_qos, 108 &null_pm_qos,
109 &cpu_dma_pm_qos, 109 &cpu_dma_pm_qos,
110 &network_lat_pm_qos, 110 &network_lat_pm_qos,
111 &network_throughput_pm_qos 111 &network_throughput_pm_qos
112 }; 112 };
113 113
114 static ssize_t pm_qos_power_write(struct file *filp, const char __user *buf, 114 static ssize_t pm_qos_power_write(struct file *filp, const char __user *buf,
115 size_t count, loff_t *f_pos); 115 size_t count, loff_t *f_pos);
116 static ssize_t pm_qos_power_read(struct file *filp, char __user *buf, 116 static ssize_t pm_qos_power_read(struct file *filp, char __user *buf,
117 size_t count, loff_t *f_pos); 117 size_t count, loff_t *f_pos);
118 static int pm_qos_power_open(struct inode *inode, struct file *filp); 118 static int pm_qos_power_open(struct inode *inode, struct file *filp);
119 static int pm_qos_power_release(struct inode *inode, struct file *filp); 119 static int pm_qos_power_release(struct inode *inode, struct file *filp);
120 120
121 static const struct file_operations pm_qos_power_fops = { 121 static const struct file_operations pm_qos_power_fops = {
122 .write = pm_qos_power_write, 122 .write = pm_qos_power_write,
123 .read = pm_qos_power_read, 123 .read = pm_qos_power_read,
124 .open = pm_qos_power_open, 124 .open = pm_qos_power_open,
125 .release = pm_qos_power_release, 125 .release = pm_qos_power_release,
126 .llseek = noop_llseek, 126 .llseek = noop_llseek,
127 }; 127 };
128 128
129 /* unlocked internal variant */ 129 /* unlocked internal variant */
130 static inline int pm_qos_get_value(struct pm_qos_object *o) 130 static inline int pm_qos_get_value(struct pm_qos_object *o)
131 { 131 {
132 if (plist_head_empty(&o->requests)) 132 if (plist_head_empty(&o->constraints))
133 return o->default_value; 133 return o->default_value;
134 134
135 switch (o->type) { 135 switch (o->type) {
136 case PM_QOS_MIN: 136 case PM_QOS_MIN:
137 return plist_first(&o->requests)->prio; 137 return plist_first(&o->constraints)->prio;
138 138
139 case PM_QOS_MAX: 139 case PM_QOS_MAX:
140 return plist_last(&o->requests)->prio; 140 return plist_last(&o->constraints)->prio;
141 141
142 default: 142 default:
143 /* runtime check for not using enum */ 143 /* runtime check for not using enum */
144 BUG(); 144 BUG();
145 } 145 }
146 } 146 }
147 147
148 static inline s32 pm_qos_read_value(struct pm_qos_object *o) 148 static inline s32 pm_qos_read_value(struct pm_qos_object *o)
149 { 149 {
150 return o->target_value; 150 return o->target_value;
151 } 151 }
152 152
153 static inline void pm_qos_set_value(struct pm_qos_object *o, s32 value) 153 static inline void pm_qos_set_value(struct pm_qos_object *o, s32 value)
154 { 154 {
155 o->target_value = value; 155 o->target_value = value;
156 } 156 }
157 157
158 static void update_target(struct pm_qos_object *o, struct plist_node *node, 158 static void update_target(struct pm_qos_object *o, struct plist_node *node,
159 int del, int value) 159 int del, int value)
160 { 160 {
161 unsigned long flags; 161 unsigned long flags;
162 int prev_value, curr_value; 162 int prev_value, curr_value;
163 163
164 spin_lock_irqsave(&pm_qos_lock, flags); 164 spin_lock_irqsave(&pm_qos_lock, flags);
165 prev_value = pm_qos_get_value(o); 165 prev_value = pm_qos_get_value(o);
166 /* PM_QOS_DEFAULT_VALUE is a signal that the value is unchanged */ 166 /* PM_QOS_DEFAULT_VALUE is a signal that the value is unchanged */
167 if (value != PM_QOS_DEFAULT_VALUE) { 167 if (value != PM_QOS_DEFAULT_VALUE) {
168 /* 168 /*
169 * to change the list, we atomically remove, reinit 169 * to change the list, we atomically remove, reinit
170 * with new value and add, then see if the extremal 170 * with new value and add, then see if the extremal
171 * changed 171 * changed
172 */ 172 */
173 plist_del(node, &o->requests); 173 plist_del(node, &o->constraints);
174 plist_node_init(node, value); 174 plist_node_init(node, value);
175 plist_add(node, &o->requests); 175 plist_add(node, &o->constraints);
176 } else if (del) { 176 } else if (del) {
177 plist_del(node, &o->requests); 177 plist_del(node, &o->constraints);
178 } else { 178 } else {
179 plist_add(node, &o->requests); 179 plist_add(node, &o->constraints);
180 } 180 }
181 curr_value = pm_qos_get_value(o); 181 curr_value = pm_qos_get_value(o);
182 pm_qos_set_value(o, curr_value); 182 pm_qos_set_value(o, curr_value);
183 spin_unlock_irqrestore(&pm_qos_lock, flags); 183 spin_unlock_irqrestore(&pm_qos_lock, flags);
184 184
185 if (prev_value != curr_value) 185 if (prev_value != curr_value)
186 blocking_notifier_call_chain(o->notifiers, 186 blocking_notifier_call_chain(o->notifiers,
187 (unsigned long)curr_value, 187 (unsigned long)curr_value,
188 NULL); 188 NULL);
189 } 189 }
190 190
191 static int register_pm_qos_misc(struct pm_qos_object *qos) 191 static int register_pm_qos_misc(struct pm_qos_object *qos)
192 { 192 {
193 qos->pm_qos_power_miscdev.minor = MISC_DYNAMIC_MINOR; 193 qos->pm_qos_power_miscdev.minor = MISC_DYNAMIC_MINOR;
194 qos->pm_qos_power_miscdev.name = qos->name; 194 qos->pm_qos_power_miscdev.name = qos->name;
195 qos->pm_qos_power_miscdev.fops = &pm_qos_power_fops; 195 qos->pm_qos_power_miscdev.fops = &pm_qos_power_fops;
196 196
197 return misc_register(&qos->pm_qos_power_miscdev); 197 return misc_register(&qos->pm_qos_power_miscdev);
198 } 198 }
199 199
200 static int find_pm_qos_object_by_minor(int minor) 200 static int find_pm_qos_object_by_minor(int minor)
201 { 201 {
202 int pm_qos_class; 202 int pm_qos_class;
203 203
204 for (pm_qos_class = 0; 204 for (pm_qos_class = 0;
205 pm_qos_class < PM_QOS_NUM_CLASSES; pm_qos_class++) { 205 pm_qos_class < PM_QOS_NUM_CLASSES; pm_qos_class++) {
206 if (minor == 206 if (minor ==
207 pm_qos_array[pm_qos_class]->pm_qos_power_miscdev.minor) 207 pm_qos_array[pm_qos_class]->pm_qos_power_miscdev.minor)
208 return pm_qos_class; 208 return pm_qos_class;
209 } 209 }
210 return -1; 210 return -1;
211 } 211 }
212 212
213 /** 213 /**
214 * pm_qos_request - returns current system wide qos expectation 214 * pm_qos_request - returns current system wide qos expectation
215 * @pm_qos_class: identification of which qos value is requested 215 * @pm_qos_class: identification of which qos value is requested
216 * 216 *
217 * This function returns the current target value. 217 * This function returns the current target value.
218 */ 218 */
219 int pm_qos_request(int pm_qos_class) 219 int pm_qos_request(int pm_qos_class)
220 { 220 {
221 return pm_qos_read_value(pm_qos_array[pm_qos_class]); 221 return pm_qos_read_value(pm_qos_array[pm_qos_class]);
222 } 222 }
223 EXPORT_SYMBOL_GPL(pm_qos_request); 223 EXPORT_SYMBOL_GPL(pm_qos_request);
224 224
225 int pm_qos_request_active(struct pm_qos_request_list *req) 225 int pm_qos_request_active(struct pm_qos_request *req)
226 { 226 {
227 return req->pm_qos_class != 0; 227 return req->pm_qos_class != 0;
228 } 228 }
229 EXPORT_SYMBOL_GPL(pm_qos_request_active); 229 EXPORT_SYMBOL_GPL(pm_qos_request_active);
230 230
231 /** 231 /**
232 * pm_qos_add_request - inserts new qos request into the list 232 * pm_qos_add_request - inserts new qos request into the list
233 * @dep: pointer to a preallocated handle 233 * @req: pointer to a preallocated handle
234 * @pm_qos_class: identifies which list of qos request to use 234 * @pm_qos_class: identifies which list of qos request to use
235 * @value: defines the qos request 235 * @value: defines the qos request
236 * 236 *
237 * This function inserts a new entry in the pm_qos_class list of requested qos 237 * This function inserts a new entry in the pm_qos_class list of requested qos
238 * performance characteristics. It recomputes the aggregate QoS expectations 238 * performance characteristics. It recomputes the aggregate QoS expectations
239 * for the pm_qos_class of parameters and initializes the pm_qos_request_list 239 * for the pm_qos_class of parameters and initializes the pm_qos_request
240 * handle. Caller needs to save this handle for later use in updates and 240 * handle. Caller needs to save this handle for later use in updates and
241 * removal. 241 * removal.
242 */ 242 */
243 243
244 void pm_qos_add_request(struct pm_qos_request_list *dep, 244 void pm_qos_add_request(struct pm_qos_request *req,
245 int pm_qos_class, s32 value) 245 int pm_qos_class, s32 value)
246 { 246 {
247 struct pm_qos_object *o = pm_qos_array[pm_qos_class]; 247 struct pm_qos_object *o = pm_qos_array[pm_qos_class];
248 int new_value; 248 int new_value;
249 249
250 if (pm_qos_request_active(dep)) { 250 if (pm_qos_request_active(req)) {
251 WARN(1, KERN_ERR "pm_qos_add_request() called for already added request\n"); 251 WARN(1, KERN_ERR "pm_qos_add_request() called for already added request\n");
252 return; 252 return;
253 } 253 }
254 if (value == PM_QOS_DEFAULT_VALUE) 254 if (value == PM_QOS_DEFAULT_VALUE)
255 new_value = o->default_value; 255 new_value = o->default_value;
256 else 256 else
257 new_value = value; 257 new_value = value;
258 plist_node_init(&dep->list, new_value); 258 plist_node_init(&req->node, new_value);
259 dep->pm_qos_class = pm_qos_class; 259 req->pm_qos_class = pm_qos_class;
260 update_target(o, &dep->list, 0, PM_QOS_DEFAULT_VALUE); 260 update_target(o, &req->node, 0, PM_QOS_DEFAULT_VALUE);
261 } 261 }
262 EXPORT_SYMBOL_GPL(pm_qos_add_request); 262 EXPORT_SYMBOL_GPL(pm_qos_add_request);
263 263
264 /** 264 /**
265 * pm_qos_update_request - modifies an existing qos request 265 * pm_qos_update_request - modifies an existing qos request
266 * @pm_qos_req : handle to list element holding a pm_qos request to use 266 * @req : handle to list element holding a pm_qos request to use
267 * @value: defines the qos request 267 * @value: defines the qos request
268 * 268 *
269 * Updates an existing qos request for the pm_qos_class of parameters along 269 * Updates an existing qos request for the pm_qos_class of parameters along
270 * with updating the target pm_qos_class value. 270 * with updating the target pm_qos_class value.
271 * 271 *
272 * Attempts are made to make this code callable on hot code paths. 272 * Attempts are made to make this code callable on hot code paths.
273 */ 273 */
274 void pm_qos_update_request(struct pm_qos_request_list *pm_qos_req, 274 void pm_qos_update_request(struct pm_qos_request *req,
275 s32 new_value) 275 s32 new_value)
276 { 276 {
277 s32 temp; 277 s32 temp;
278 struct pm_qos_object *o; 278 struct pm_qos_object *o;
279 279
280 if (!pm_qos_req) /*guard against callers passing in null */ 280 if (!req) /*guard against callers passing in null */
281 return; 281 return;
282 282
283 if (!pm_qos_request_active(pm_qos_req)) { 283 if (!pm_qos_request_active(req)) {
284 WARN(1, KERN_ERR "pm_qos_update_request() called for unknown object\n"); 284 WARN(1, KERN_ERR "pm_qos_update_request() called for unknown object\n");
285 return; 285 return;
286 } 286 }
287 287
288 o = pm_qos_array[pm_qos_req->pm_qos_class]; 288 o = pm_qos_array[req->pm_qos_class];
289 289
290 if (new_value == PM_QOS_DEFAULT_VALUE) 290 if (new_value == PM_QOS_DEFAULT_VALUE)
291 temp = o->default_value; 291 temp = o->default_value;
292 else 292 else
293 temp = new_value; 293 temp = new_value;
294 294
295 if (temp != pm_qos_req->list.prio) 295 if (temp != req->node.prio)
296 update_target(o, &pm_qos_req->list, 0, temp); 296 update_target(o, &req->node, 0, temp);
297 } 297 }
298 EXPORT_SYMBOL_GPL(pm_qos_update_request); 298 EXPORT_SYMBOL_GPL(pm_qos_update_request);
299 299
300 /** 300 /**
301 * pm_qos_remove_request - modifies an existing qos request 301 * pm_qos_remove_request - modifies an existing qos request
302 * @pm_qos_req: handle to request list element 302 * @req: handle to request list element
303 * 303 *
304 * Will remove pm qos request from the list of requests and 304 * Will remove pm qos request from the list of constraints and
305 * recompute the current target value for the pm_qos_class. Call this 305 * recompute the current target value for the pm_qos_class. Call this
306 * on slow code paths. 306 * on slow code paths.
307 */ 307 */
308 void pm_qos_remove_request(struct pm_qos_request_list *pm_qos_req) 308 void pm_qos_remove_request(struct pm_qos_request *req)
309 { 309 {
310 struct pm_qos_object *o; 310 struct pm_qos_object *o;
311 311
312 if (pm_qos_req == NULL) 312 if (req == NULL)
313 return; 313 return;
314 /* silent return to keep pcm code cleaner */ 314 /* silent return to keep pcm code cleaner */
315 315
316 if (!pm_qos_request_active(pm_qos_req)) { 316 if (!pm_qos_request_active(req)) {
317 WARN(1, KERN_ERR "pm_qos_remove_request() called for unknown object\n"); 317 WARN(1, KERN_ERR "pm_qos_remove_request() called for unknown object\n");
318 return; 318 return;
319 } 319 }
320 320
321 o = pm_qos_array[pm_qos_req->pm_qos_class]; 321 o = pm_qos_array[req->pm_qos_class];
322 update_target(o, &pm_qos_req->list, 1, PM_QOS_DEFAULT_VALUE); 322 update_target(o, &req->node, 1, PM_QOS_DEFAULT_VALUE);
323 memset(pm_qos_req, 0, sizeof(*pm_qos_req)); 323 memset(req, 0, sizeof(*req));
324 } 324 }
325 EXPORT_SYMBOL_GPL(pm_qos_remove_request); 325 EXPORT_SYMBOL_GPL(pm_qos_remove_request);
326 326
327 /** 327 /**
328 * pm_qos_add_notifier - sets notification entry for changes to target value 328 * pm_qos_add_notifier - sets notification entry for changes to target value
329 * @pm_qos_class: identifies which qos target changes should be notified. 329 * @pm_qos_class: identifies which qos target changes should be notified.
330 * @notifier: notifier block managed by caller. 330 * @notifier: notifier block managed by caller.
331 * 331 *
332 * will register the notifier into a notification chain that gets called 332 * will register the notifier into a notification chain that gets called
333 * upon changes to the pm_qos_class target value. 333 * upon changes to the pm_qos_class target value.
334 */ 334 */
335 int pm_qos_add_notifier(int pm_qos_class, struct notifier_block *notifier) 335 int pm_qos_add_notifier(int pm_qos_class, struct notifier_block *notifier)
336 { 336 {
337 int retval; 337 int retval;
338 338
339 retval = blocking_notifier_chain_register( 339 retval = blocking_notifier_chain_register(
340 pm_qos_array[pm_qos_class]->notifiers, notifier); 340 pm_qos_array[pm_qos_class]->notifiers, notifier);
341 341
342 return retval; 342 return retval;
343 } 343 }
344 EXPORT_SYMBOL_GPL(pm_qos_add_notifier); 344 EXPORT_SYMBOL_GPL(pm_qos_add_notifier);
345 345
346 /** 346 /**
347 * pm_qos_remove_notifier - deletes notification entry from chain. 347 * pm_qos_remove_notifier - deletes notification entry from chain.
348 * @pm_qos_class: identifies which qos target changes are notified. 348 * @pm_qos_class: identifies which qos target changes are notified.
349 * @notifier: notifier block to be removed. 349 * @notifier: notifier block to be removed.
350 * 350 *
351 * will remove the notifier from the notification chain that gets called 351 * will remove the notifier from the notification chain that gets called
352 * upon changes to the pm_qos_class target value. 352 * upon changes to the pm_qos_class target value.
353 */ 353 */
354 int pm_qos_remove_notifier(int pm_qos_class, struct notifier_block *notifier) 354 int pm_qos_remove_notifier(int pm_qos_class, struct notifier_block *notifier)
355 { 355 {
356 int retval; 356 int retval;
357 357
358 retval = blocking_notifier_chain_unregister( 358 retval = blocking_notifier_chain_unregister(
359 pm_qos_array[pm_qos_class]->notifiers, notifier); 359 pm_qos_array[pm_qos_class]->notifiers, notifier);
360 360
361 return retval; 361 return retval;
362 } 362 }
363 EXPORT_SYMBOL_GPL(pm_qos_remove_notifier); 363 EXPORT_SYMBOL_GPL(pm_qos_remove_notifier);
364 364
365 static int pm_qos_power_open(struct inode *inode, struct file *filp) 365 static int pm_qos_power_open(struct inode *inode, struct file *filp)
366 { 366 {
367 long pm_qos_class; 367 long pm_qos_class;
368 368
369 pm_qos_class = find_pm_qos_object_by_minor(iminor(inode)); 369 pm_qos_class = find_pm_qos_object_by_minor(iminor(inode));
370 if (pm_qos_class >= 0) { 370 if (pm_qos_class >= 0) {
371 struct pm_qos_request_list *req = kzalloc(sizeof(*req), GFP_KERNEL); 371 struct pm_qos_request *req = kzalloc(sizeof(*req), GFP_KERNEL);
372 if (!req) 372 if (!req)
373 return -ENOMEM; 373 return -ENOMEM;
374 374
375 pm_qos_add_request(req, pm_qos_class, PM_QOS_DEFAULT_VALUE); 375 pm_qos_add_request(req, pm_qos_class, PM_QOS_DEFAULT_VALUE);
376 filp->private_data = req; 376 filp->private_data = req;
377 377
378 if (filp->private_data) 378 if (filp->private_data)
379 return 0; 379 return 0;
380 } 380 }
381 return -EPERM; 381 return -EPERM;
382 } 382 }
383 383
384 static int pm_qos_power_release(struct inode *inode, struct file *filp) 384 static int pm_qos_power_release(struct inode *inode, struct file *filp)
385 { 385 {
386 struct pm_qos_request_list *req; 386 struct pm_qos_request *req;
387 387
388 req = filp->private_data; 388 req = filp->private_data;
389 pm_qos_remove_request(req); 389 pm_qos_remove_request(req);
390 kfree(req); 390 kfree(req);
391 391
392 return 0; 392 return 0;
393 } 393 }
394 394
395 395
396 static ssize_t pm_qos_power_read(struct file *filp, char __user *buf, 396 static ssize_t pm_qos_power_read(struct file *filp, char __user *buf,
397 size_t count, loff_t *f_pos) 397 size_t count, loff_t *f_pos)
398 { 398 {
399 s32 value; 399 s32 value;
400 unsigned long flags; 400 unsigned long flags;
401 struct pm_qos_object *o; 401 struct pm_qos_object *o;
402 struct pm_qos_request_list *pm_qos_req = filp->private_data; 402 struct pm_qos_request *req = filp->private_data;
403 403
404 if (!pm_qos_req) 404 if (!req)
405 return -EINVAL; 405 return -EINVAL;
406 if (!pm_qos_request_active(pm_qos_req)) 406 if (!pm_qos_request_active(req))
407 return -EINVAL; 407 return -EINVAL;
408 408
409 o = pm_qos_array[pm_qos_req->pm_qos_class]; 409 o = pm_qos_array[req->pm_qos_class];
410 spin_lock_irqsave(&pm_qos_lock, flags); 410 spin_lock_irqsave(&pm_qos_lock, flags);
411 value = pm_qos_get_value(o); 411 value = pm_qos_get_value(o);
412 spin_unlock_irqrestore(&pm_qos_lock, flags); 412 spin_unlock_irqrestore(&pm_qos_lock, flags);
413 413
414 return simple_read_from_buffer(buf, count, f_pos, &value, sizeof(s32)); 414 return simple_read_from_buffer(buf, count, f_pos, &value, sizeof(s32));
415 } 415 }
416 416
417 static ssize_t pm_qos_power_write(struct file *filp, const char __user *buf, 417 static ssize_t pm_qos_power_write(struct file *filp, const char __user *buf,
418 size_t count, loff_t *f_pos) 418 size_t count, loff_t *f_pos)
419 { 419 {
420 s32 value; 420 s32 value;
421 struct pm_qos_request_list *pm_qos_req; 421 struct pm_qos_request *req;
422 422
423 if (count == sizeof(s32)) { 423 if (count == sizeof(s32)) {
424 if (copy_from_user(&value, buf, sizeof(s32))) 424 if (copy_from_user(&value, buf, sizeof(s32)))
425 return -EFAULT; 425 return -EFAULT;
426 } else if (count <= 11) { /* ASCII perhaps? */ 426 } else if (count <= 11) { /* ASCII perhaps? */
427 char ascii_value[11]; 427 char ascii_value[11];
428 unsigned long int ulval; 428 unsigned long int ulval;
429 int ret; 429 int ret;
430 430
431 if (copy_from_user(ascii_value, buf, count)) 431 if (copy_from_user(ascii_value, buf, count))
432 return -EFAULT; 432 return -EFAULT;
433 433
434 if (count > 10) { 434 if (count > 10) {
435 if (ascii_value[10] == '\n') 435 if (ascii_value[10] == '\n')
436 ascii_value[10] = '\0'; 436 ascii_value[10] = '\0';
437 else 437 else
438 return -EINVAL; 438 return -EINVAL;
439 } else { 439 } else {
440 ascii_value[count] = '\0'; 440 ascii_value[count] = '\0';
441 } 441 }
442 ret = strict_strtoul(ascii_value, 16, &ulval); 442 ret = strict_strtoul(ascii_value, 16, &ulval);
443 if (ret) { 443 if (ret) {
444 pr_debug("%s, 0x%lx, 0x%x\n", ascii_value, ulval, ret); 444 pr_debug("%s, 0x%lx, 0x%x\n", ascii_value, ulval, ret);
445 return -EINVAL; 445 return -EINVAL;
446 } 446 }
447 value = (s32)lower_32_bits(ulval); 447 value = (s32)lower_32_bits(ulval);
448 } else { 448 } else {
449 return -EINVAL; 449 return -EINVAL;
450 } 450 }
451 451
452 pm_qos_req = filp->private_data; 452 req = filp->private_data;
453 pm_qos_update_request(pm_qos_req, value); 453 pm_qos_update_request(req, value);
454 454
455 return count; 455 return count;
456 } 456 }
457 457
458 458
459 static int __init pm_qos_power_init(void) 459 static int __init pm_qos_power_init(void)
460 { 460 {
461 int ret = 0; 461 int ret = 0;
462 462
463 ret = register_pm_qos_misc(&cpu_dma_pm_qos); 463 ret = register_pm_qos_misc(&cpu_dma_pm_qos);
464 if (ret < 0) { 464 if (ret < 0) {
465 printk(KERN_ERR "pm_qos_param: cpu_dma_latency setup failed\n"); 465 printk(KERN_ERR "pm_qos_param: cpu_dma_latency setup failed\n");
466 return ret; 466 return ret;
467 } 467 }
468 ret = register_pm_qos_misc(&network_lat_pm_qos); 468 ret = register_pm_qos_misc(&network_lat_pm_qos);
469 if (ret < 0) { 469 if (ret < 0) {
470 printk(KERN_ERR "pm_qos_param: network_latency setup failed\n"); 470 printk(KERN_ERR "pm_qos_param: network_latency setup failed\n");
471 return ret; 471 return ret;
472 } 472 }
473 ret = register_pm_qos_misc(&network_throughput_pm_qos); 473 ret = register_pm_qos_misc(&network_throughput_pm_qos);
474 if (ret < 0) 474 if (ret < 0)
475 printk(KERN_ERR 475 printk(KERN_ERR
476 "pm_qos_param: network_throughput setup failed\n"); 476 "pm_qos_param: network_throughput setup failed\n");
477 477
478 return ret; 478 return ret;
479 } 479 }
480 480
481 late_initcall(pm_qos_power_init); 481 late_initcall(pm_qos_power_init);
482 482