Diff markup
1 /* 1 /*
2 * Driver for ST5481 USB ISDN modem 2 * Driver for ST5481 USB ISDN modem
3 * 3 *
4 * Author Frode Isaksen 4 * Author Frode Isaksen
5 * Copyright 2001 by Frode Isaksen <fi 5 * Copyright 2001 by Frode Isaksen <fisaksen@bewan.com>
6 * 2001 by Kai Germaschewski <ka 6 * 2001 by Kai Germaschewski <kai.germaschewski@gmx.de>
7 * 7 *
8 * This software may be used and distributed a 8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorpor 9 * of the GNU General Public License, incorporated herein by reference.
10 * 10 *
11 */ 11 */
12 12
13 #include <linux/init.h> 13 #include <linux/init.h>
14 #include <linux/usb.h> 14 #include <linux/usb.h>
15 #include <linux/slab.h> 15 #include <linux/slab.h>
16 #include "st5481.h" 16 #include "st5481.h"
17 17
18 static int st5481_isoc_flatten(struct urb *urb 18 static int st5481_isoc_flatten(struct urb *urb);
19 19
20 /* =========================================== 20 /* ======================================================================
21 * control pipe 21 * control pipe
22 */ 22 */
23 23
24 /* 24 /*
25 * Send the next endpoint 0 request stored in 25 * Send the next endpoint 0 request stored in the FIFO.
26 * Called either by the completion or by usb_c 26 * Called either by the completion or by usb_ctrl_msg.
27 */ 27 */
28 static void usb_next_ctrl_msg(struct urb *urb, 28 static void usb_next_ctrl_msg(struct urb *urb,
29 struct st5481_ad 29 struct st5481_adapter *adapter)
30 { 30 {
31 struct st5481_ctrl *ctrl = &adapter->c 31 struct st5481_ctrl *ctrl = &adapter->ctrl;
32 int r_index; 32 int r_index;
33 33
34 if (test_and_set_bit(0, &ctrl->busy)) 34 if (test_and_set_bit(0, &ctrl->busy)) {
35 return; 35 return;
36 } 36 }
37 37
38 if ((r_index = fifo_remove(&ctrl->msg_ 38 if ((r_index = fifo_remove(&ctrl->msg_fifo.f)) < 0) {
39 test_and_clear_bit(0,&ctrl->bu 39 test_and_clear_bit(0,&ctrl->busy);
40 return; 40 return;
41 } 41 }
42 urb->setup_packet = 42 urb->setup_packet =
43 (unsigned char *)&ctrl->msg_fi 43 (unsigned char *)&ctrl->msg_fifo.data[r_index];
44 44
45 DBG(1,"request=0x%02x,value=0x%04x,ind 45 DBG(1,"request=0x%02x,value=0x%04x,index=%x",
46 ((struct ctrl_msg *)urb->setup_pac 46 ((struct ctrl_msg *)urb->setup_packet)->dr.bRequest,
47 ((struct ctrl_msg *)urb->setup_pac 47 ((struct ctrl_msg *)urb->setup_packet)->dr.wValue,
48 ((struct ctrl_msg *)urb->setup_pac 48 ((struct ctrl_msg *)urb->setup_packet)->dr.wIndex);
49 49
50 // Prepare the URB 50 // Prepare the URB
51 urb->dev = adapter->usb_dev; 51 urb->dev = adapter->usb_dev;
52 52
53 SUBMIT_URB(urb, GFP_ATOMIC); 53 SUBMIT_URB(urb, GFP_ATOMIC);
54 } 54 }
55 55
56 /* 56 /*
57 * Asynchronous endpoint 0 request (async vers 57 * Asynchronous endpoint 0 request (async version of usb_control_msg).
58 * The request will be queued up in a FIFO if 58 * The request will be queued up in a FIFO if the endpoint is busy.
59 */ 59 */
60 static void usb_ctrl_msg(struct st5481_adapter 60 static void usb_ctrl_msg(struct st5481_adapter *adapter,
61 u8 request, u8 reques 61 u8 request, u8 requesttype, u16 value, u16 index,
62 ctrl_complete_t compl 62 ctrl_complete_t complete, void *context)
63 { 63 {
64 struct st5481_ctrl *ctrl = &adapter->c 64 struct st5481_ctrl *ctrl = &adapter->ctrl;
65 int w_index; 65 int w_index;
66 struct ctrl_msg *ctrl_msg; 66 struct ctrl_msg *ctrl_msg;
67 67
68 if ((w_index = fifo_add(&ctrl->msg_fif 68 if ((w_index = fifo_add(&ctrl->msg_fifo.f)) < 0) {
69 WARN("control msg FIFO full"); 69 WARN("control msg FIFO full");
70 return; 70 return;
71 } 71 }
72 ctrl_msg = &ctrl->msg_fifo.data[w_inde 72 ctrl_msg = &ctrl->msg_fifo.data[w_index];
73 73
74 ctrl_msg->dr.bRequestType = requesttyp 74 ctrl_msg->dr.bRequestType = requesttype;
75 ctrl_msg->dr.bRequest = request; 75 ctrl_msg->dr.bRequest = request;
76 ctrl_msg->dr.wValue = cpu_to_le16p(&va 76 ctrl_msg->dr.wValue = cpu_to_le16p(&value);
77 ctrl_msg->dr.wIndex = cpu_to_le16p(&in 77 ctrl_msg->dr.wIndex = cpu_to_le16p(&index);
78 ctrl_msg->dr.wLength = 0; 78 ctrl_msg->dr.wLength = 0;
79 ctrl_msg->complete = complete; 79 ctrl_msg->complete = complete;
80 ctrl_msg->context = context; 80 ctrl_msg->context = context;
81 81
82 usb_next_ctrl_msg(ctrl->urb, adapter); 82 usb_next_ctrl_msg(ctrl->urb, adapter);
83 } 83 }
84 84
85 /* 85 /*
86 * Asynchronous endpoint 0 device request. 86 * Asynchronous endpoint 0 device request.
87 */ 87 */
88 void st5481_usb_device_ctrl_msg(struct st5481_ 88 void st5481_usb_device_ctrl_msg(struct st5481_adapter *adapter,
89 u8 request, u16 value 89 u8 request, u16 value,
90 ctrl_complete_t compl 90 ctrl_complete_t complete, void *context)
91 { 91 {
92 usb_ctrl_msg(adapter, request, 92 usb_ctrl_msg(adapter, request,
93 USB_DIR_OUT | USB_TYPE_VE 93 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
94 value, 0, complete, conte 94 value, 0, complete, context);
95 } 95 }
96 96
97 /* 97 /*
98 * Asynchronous pipe reset (async version of u 98 * Asynchronous pipe reset (async version of usb_clear_halt).
99 */ 99 */
100 void st5481_usb_pipe_reset(struct st5481_adapt 100 void st5481_usb_pipe_reset(struct st5481_adapter *adapter,
101 u_char pipe, 101 u_char pipe,
102 ctrl_complete_t complete, 102 ctrl_complete_t complete, void *context)
103 { 103 {
104 DBG(1,"pipe=%02x",pipe); 104 DBG(1,"pipe=%02x",pipe);
105 105
106 usb_ctrl_msg(adapter, 106 usb_ctrl_msg(adapter,
107 USB_REQ_CLEAR_FEATURE, US 107 USB_REQ_CLEAR_FEATURE, USB_DIR_OUT | USB_RECIP_ENDPOINT,
108 0, pipe, complete, contex 108 0, pipe, complete, context);
109 } 109 }
110 110
111 111
112 /* 112 /*
113 Physical level functions 113 Physical level functions
114 */ 114 */
115 115
116 void st5481_ph_command(struct st5481_adapter * 116 void st5481_ph_command(struct st5481_adapter *adapter, unsigned int command)
117 { 117 {
118 DBG(8,"command=%s", ST5481_CMD_string( 118 DBG(8,"command=%s", ST5481_CMD_string(command));
119 119
120 st5481_usb_device_ctrl_msg(adapter, TX 120 st5481_usb_device_ctrl_msg(adapter, TXCI, command, NULL, NULL);
121 } 121 }
122 122
123 /* 123 /*
124 * The request on endpoint 0 has completed. 124 * The request on endpoint 0 has completed.
125 * Call the user provided completion routine a 125 * Call the user provided completion routine and try
126 * to send the next request. 126 * to send the next request.
127 */ 127 */
128 static void usb_ctrl_complete(struct urb *urb) 128 static void usb_ctrl_complete(struct urb *urb)
129 { 129 {
130 struct st5481_adapter *adapter = urb-> 130 struct st5481_adapter *adapter = urb->context;
131 struct st5481_ctrl *ctrl = &adapter->c 131 struct st5481_ctrl *ctrl = &adapter->ctrl;
132 struct ctrl_msg *ctrl_msg; 132 struct ctrl_msg *ctrl_msg;
133 133
134 if (unlikely(urb->status < 0)) { 134 if (unlikely(urb->status < 0)) {
135 switch (urb->status) { 135 switch (urb->status) {
136 case -ENOENT: 136 case -ENOENT:
137 case -ESHUTDOWN: 137 case -ESHUTDOWN:
138 case -ECONNRESET: 138 case -ECONNRESET:
139 DBG(1,"urb kil 139 DBG(1,"urb killed status %d", urb->status);
140 return; // Giv 140 return; // Give up
141 default: 141 default:
142 WARN("urb stat 142 WARN("urb status %d",urb->status);
143 break; 143 break;
144 } 144 }
145 } 145 }
146 146
147 ctrl_msg = (struct ctrl_msg *)urb->set 147 ctrl_msg = (struct ctrl_msg *)urb->setup_packet;
148 148
149 if (ctrl_msg->dr.bRequest == USB_REQ_C 149 if (ctrl_msg->dr.bRequest == USB_REQ_CLEAR_FEATURE) {
150 /* Special case handling for p 150 /* Special case handling for pipe reset */
151 le16_to_cpus(&ctrl_msg->dr.wIn 151 le16_to_cpus(&ctrl_msg->dr.wIndex);
152 152
153 /* toggle is reset on clear */ 153 /* toggle is reset on clear */
154 usb_settoggle(adapter->usb_dev 154 usb_settoggle(adapter->usb_dev,
155 ctrl_msg->dr.wIn 155 ctrl_msg->dr.wIndex & ~USB_DIR_IN,
156 (ctrl_msg->dr.wI 156 (ctrl_msg->dr.wIndex & USB_DIR_IN) == 0,
157 0); 157 0);
158 158
159 159
160 } 160 }
161 161
162 if (ctrl_msg->complete) 162 if (ctrl_msg->complete)
163 ctrl_msg->complete(ctrl_msg->c 163 ctrl_msg->complete(ctrl_msg->context);
164 164
165 clear_bit(0, &ctrl->busy); 165 clear_bit(0, &ctrl->busy);
166 166
167 // Try to send next control message 167 // Try to send next control message
168 usb_next_ctrl_msg(urb, adapter); 168 usb_next_ctrl_msg(urb, adapter);
169 return; 169 return;
170 } 170 }
171 171
172 /* =========================================== 172 /* ======================================================================
173 * interrupt pipe 173 * interrupt pipe
174 */ 174 */
175 175
176 /* 176 /*
177 * The interrupt endpoint will be called when 177 * The interrupt endpoint will be called when any
178 * of the 6 registers changes state (depending 178 * of the 6 registers changes state (depending on masks).
179 * Decode the register values and schedule a p 179 * Decode the register values and schedule a private event.
180 * Called at interrupt. 180 * Called at interrupt.
181 */ 181 */
182 static void usb_int_complete(struct urb *urb) 182 static void usb_int_complete(struct urb *urb)
183 { 183 {
184 u8 *data = urb->transfer_buffer; 184 u8 *data = urb->transfer_buffer;
185 u8 irqbyte; 185 u8 irqbyte;
186 struct st5481_adapter *adapter = urb-> 186 struct st5481_adapter *adapter = urb->context;
187 int j; 187 int j;
188 int status; 188 int status;
189 189
190 switch (urb->status) { 190 switch (urb->status) {
191 case 0: 191 case 0:
192 /* success */ 192 /* success */
193 break; 193 break;
194 case -ECONNRESET: 194 case -ECONNRESET:
195 case -ENOENT: 195 case -ENOENT:
196 case -ESHUTDOWN: 196 case -ESHUTDOWN:
197 /* this urb is termina 197 /* this urb is terminated, clean up */
198 DBG(2, "urb shutting d 198 DBG(2, "urb shutting down with status: %d", urb->status);
199 return; 199 return;
200 default: 200 default:
201 WARN("nonzero urb stat 201 WARN("nonzero urb status received: %d", urb->status);
202 goto exit; 202 goto exit;
203 } 203 }
204 204
205 205
206 DBG_PACKET(2, data, INT_PKT_SIZE); 206 DBG_PACKET(2, data, INT_PKT_SIZE);
207 207
208 if (urb->actual_length == 0) { 208 if (urb->actual_length == 0) {
209 goto exit; 209 goto exit;
210 } 210 }
211 211
212 irqbyte = data[MPINT]; 212 irqbyte = data[MPINT];
213 if (irqbyte & DEN_INT) 213 if (irqbyte & DEN_INT)
214 FsmEvent(&adapter->d_out.fsm, 214 FsmEvent(&adapter->d_out.fsm, EV_DOUT_DEN, NULL);
215 215
216 if (irqbyte & DCOLL_INT) 216 if (irqbyte & DCOLL_INT)
217 FsmEvent(&adapter->d_out.fsm, 217 FsmEvent(&adapter->d_out.fsm, EV_DOUT_COLL, NULL);
218 218
219 irqbyte = data[FFINT_D]; 219 irqbyte = data[FFINT_D];
220 if (irqbyte & OUT_UNDERRUN) 220 if (irqbyte & OUT_UNDERRUN)
221 FsmEvent(&adapter->d_out.fsm, 221 FsmEvent(&adapter->d_out.fsm, EV_DOUT_UNDERRUN, NULL);
222 222
223 if (irqbyte & OUT_DOWN) 223 if (irqbyte & OUT_DOWN)
224 ;// printk("OUT_DOWN\n"); 224 ;// printk("OUT_DOWN\n");
225 225
226 irqbyte = data[MPINT]; 226 irqbyte = data[MPINT];
227 if (irqbyte & RXCI_INT) 227 if (irqbyte & RXCI_INT)
228 FsmEvent(&adapter->l1m, data[C 228 FsmEvent(&adapter->l1m, data[CCIST] & 0x0f, NULL);
229 229
230 for (j = 0; j < 2; j++) 230 for (j = 0; j < 2; j++)
231 adapter->bcs[j].b_out.flow_eve 231 adapter->bcs[j].b_out.flow_event |= data[FFINT_B1 + j];
232 232
233 urb->actual_length = 0; 233 urb->actual_length = 0;
234 234
235 exit: 235 exit:
236 status = usb_submit_urb (urb, GFP_ATOM 236 status = usb_submit_urb (urb, GFP_ATOMIC);
237 if (status) 237 if (status)
238 WARN("usb_submit_urb failed wi 238 WARN("usb_submit_urb failed with result %d", status);
239 } 239 }
240 240
241 /* =========================================== 241 /* ======================================================================
242 * initialization 242 * initialization
243 */ 243 */
244 244
245 int st5481_setup_usb(struct st5481_adapter *ad 245 int st5481_setup_usb(struct st5481_adapter *adapter)
246 { 246 {
247 struct usb_device *dev = adapter->usb_ 247 struct usb_device *dev = adapter->usb_dev;
248 struct st5481_ctrl *ctrl = &adapter->c 248 struct st5481_ctrl *ctrl = &adapter->ctrl;
249 struct st5481_intr *intr = &adapter->i 249 struct st5481_intr *intr = &adapter->intr;
250 struct usb_interface *intf; 250 struct usb_interface *intf;
251 struct usb_host_interface *altsetting 251 struct usb_host_interface *altsetting = NULL;
252 struct usb_host_endpoint *endpoint; 252 struct usb_host_endpoint *endpoint;
253 int status; 253 int status;
254 struct urb *urb; 254 struct urb *urb;
255 u8 *buf; 255 u8 *buf;
256 256
257 DBG(2,""); 257 DBG(2,"");
258 258
259 if ((status = usb_reset_configuration 259 if ((status = usb_reset_configuration (dev)) < 0) {
260 WARN("reset_configuration fail 260 WARN("reset_configuration failed,status=%d",status);
261 return status; 261 return status;
262 } 262 }
263 263
264 intf = usb_ifnum_to_if(dev, 0); 264 intf = usb_ifnum_to_if(dev, 0);
265 if (intf) 265 if (intf)
266 altsetting = usb_altnum_to_alt 266 altsetting = usb_altnum_to_altsetting(intf, 3);
267 if (!altsetting) 267 if (!altsetting)
268 return -ENXIO; 268 return -ENXIO;
269 269
270 // Check if the config is sane 270 // Check if the config is sane
271 if ( altsetting->desc.bNumEndpoints != 271 if ( altsetting->desc.bNumEndpoints != 7 ) {
272 WARN("expecting 7 got %d endpo 272 WARN("expecting 7 got %d endpoints!", altsetting->desc.bNumEndpoints);
273 return -EINVAL; 273 return -EINVAL;
274 } 274 }
275 275
276 // The descriptor is wrong for some ea 276 // The descriptor is wrong for some early samples of the ST5481 chip
277 altsetting->endpoint[3].desc.wMaxPacke 277 altsetting->endpoint[3].desc.wMaxPacketSize = __constant_cpu_to_le16(32);
278 altsetting->endpoint[4].desc.wMaxPacke 278 altsetting->endpoint[4].desc.wMaxPacketSize = __constant_cpu_to_le16(32);
279 279
280 // Use alternative setting 3 on interf 280 // Use alternative setting 3 on interface 0 to have 2B+D
281 if ((status = usb_set_interface (dev, 281 if ((status = usb_set_interface (dev, 0, 3)) < 0) {
282 WARN("usb_set_interface failed 282 WARN("usb_set_interface failed,status=%d",status);
283 return status; 283 return status;
284 } 284 }
285 285
286 // Allocate URB for control endpoint 286 // Allocate URB for control endpoint
287 urb = usb_alloc_urb(0, GFP_KERNEL); 287 urb = usb_alloc_urb(0, GFP_KERNEL);
288 if (!urb) { 288 if (!urb) {
289 return -ENOMEM; 289 return -ENOMEM;
290 } 290 }
291 ctrl->urb = urb; 291 ctrl->urb = urb;
292 292
293 // Fill the control URB 293 // Fill the control URB
294 usb_fill_control_urb (urb, dev, 294 usb_fill_control_urb (urb, dev,
295 usb_sndctrlpipe(dev, 295 usb_sndctrlpipe(dev, 0),
296 NULL, NULL, 0, usb_c 296 NULL, NULL, 0, usb_ctrl_complete, adapter);
297 297
298 298
299 fifo_init(&ctrl->msg_fifo.f, ARRAY_SIZ 299 fifo_init(&ctrl->msg_fifo.f, ARRAY_SIZE(ctrl->msg_fifo.data));
300 300
301 // Allocate URBs and buffers for inter 301 // Allocate URBs and buffers for interrupt endpoint
302 urb = usb_alloc_urb(0, GFP_KERNEL); 302 urb = usb_alloc_urb(0, GFP_KERNEL);
303 if (!urb) { 303 if (!urb) {
304 return -ENOMEM; 304 return -ENOMEM;
305 } 305 }
306 intr->urb = urb; 306 intr->urb = urb;
307 307
308 buf = kmalloc(INT_PKT_SIZE, GFP_KERNEL 308 buf = kmalloc(INT_PKT_SIZE, GFP_KERNEL);
309 if (!buf) { 309 if (!buf) {
310 return -ENOMEM; 310 return -ENOMEM;
311 } 311 }
312 312
313 endpoint = &altsetting->endpoint[EP_IN 313 endpoint = &altsetting->endpoint[EP_INT-1];
314 314
315 // Fill the interrupt URB 315 // Fill the interrupt URB
316 usb_fill_int_urb(urb, dev, 316 usb_fill_int_urb(urb, dev,
317 usb_rcvintpipe(dev, endpo 317 usb_rcvintpipe(dev, endpoint->desc.bEndpointAddress),
318 buf, INT_PKT_SIZE, 318 buf, INT_PKT_SIZE,
319 usb_int_complete, adapter 319 usb_int_complete, adapter,
320 endpoint->desc.bInterval) 320 endpoint->desc.bInterval);
321 321
322 return 0; 322 return 0;
323 } 323 }
324 324
325 /* 325 /*
326 * Release buffers and URBs for the interrupt 326 * Release buffers and URBs for the interrupt and control
327 * endpoint. 327 * endpoint.
328 */ 328 */
329 void st5481_release_usb(struct st5481_adapter 329 void st5481_release_usb(struct st5481_adapter *adapter)
330 { 330 {
331 struct st5481_intr *intr = &adapter->i 331 struct st5481_intr *intr = &adapter->intr;
332 struct st5481_ctrl *ctrl = &adapter->c 332 struct st5481_ctrl *ctrl = &adapter->ctrl;
333 333
334 DBG(1,""); 334 DBG(1,"");
335 335
336 // Stop and free Control and Interrupt 336 // Stop and free Control and Interrupt URBs
337 usb_kill_urb(ctrl->urb); 337 usb_kill_urb(ctrl->urb);
338 kfree(ctrl->urb->transfer_buffer); 338 kfree(ctrl->urb->transfer_buffer);
339 usb_free_urb(ctrl->urb); 339 usb_free_urb(ctrl->urb);
340 ctrl->urb = NULL; 340 ctrl->urb = NULL;
341 341
342 usb_kill_urb(intr->urb); 342 usb_kill_urb(intr->urb);
343 kfree(intr->urb->transfer_buffer); 343 kfree(intr->urb->transfer_buffer);
344 usb_free_urb(intr->urb); 344 usb_free_urb(intr->urb);
345 ctrl->urb = NULL; 345 ctrl->urb = NULL;
346 } 346 }
347 347
348 /* 348 /*
349 * Initialize the adapter. 349 * Initialize the adapter.
350 */ 350 */
351 void st5481_start(struct st5481_adapter *adapt 351 void st5481_start(struct st5481_adapter *adapter)
352 { 352 {
353 static const u8 init_cmd_table[]={ 353 static const u8 init_cmd_table[]={
354 SET_DEFAULT,0, 354 SET_DEFAULT,0,
355 STT,0, 355 STT,0,
356 SDA_MIN,0x0d, 356 SDA_MIN,0x0d,
357 SDA_MAX,0x29, 357 SDA_MAX,0x29,
358 SDELAY_VALUE,0x14, 358 SDELAY_VALUE,0x14,
359 GPIO_DIR,0x01, 359 GPIO_DIR,0x01,
360 GPIO_OUT,RED_LED, 360 GPIO_OUT,RED_LED,
361 // FFCTRL_OUT_D,4, 361 // FFCTRL_OUT_D,4,
362 // FFCTRH_OUT_D,12, 362 // FFCTRH_OUT_D,12,
363 FFCTRL_OUT_B1,6, 363 FFCTRL_OUT_B1,6,
364 FFCTRH_OUT_B1,20, 364 FFCTRH_OUT_B1,20,
365 FFCTRL_OUT_B2,6, 365 FFCTRL_OUT_B2,6,
366 FFCTRH_OUT_B2,20, 366 FFCTRH_OUT_B2,20,
367 MPMSK,RXCI_INT+DEN_INT+DCOLL_I 367 MPMSK,RXCI_INT+DEN_INT+DCOLL_INT,
368 0 368 0
369 }; 369 };
370 struct st5481_intr *intr = &adapter->i 370 struct st5481_intr *intr = &adapter->intr;
371 int i = 0; 371 int i = 0;
372 u8 request,value; 372 u8 request,value;
373 373
374 DBG(8,""); 374 DBG(8,"");
375 375
376 adapter->leds = RED_LED; 376 adapter->leds = RED_LED;
377 377
378 // Start receiving on the interrupt en 378 // Start receiving on the interrupt endpoint
379 SUBMIT_URB(intr->urb, GFP_KERNEL); 379 SUBMIT_URB(intr->urb, GFP_KERNEL);
380 380
381 while ((request = init_cmd_table[i++]) 381 while ((request = init_cmd_table[i++])) {
382 value = init_cmd_table[i++]; 382 value = init_cmd_table[i++];
383 st5481_usb_device_ctrl_msg(ada 383 st5481_usb_device_ctrl_msg(adapter, request, value, NULL, NULL);
384 } 384 }
385 st5481_ph_command(adapter, ST5481_CMD_ 385 st5481_ph_command(adapter, ST5481_CMD_PUP);
386 } 386 }
387 387
388 /* 388 /*
389 * Reset the adapter to default values. 389 * Reset the adapter to default values.
390 */ 390 */
391 void st5481_stop(struct st5481_adapter *adapte 391 void st5481_stop(struct st5481_adapter *adapter)
392 { 392 {
393 DBG(8,""); 393 DBG(8,"");
394 394
395 st5481_usb_device_ctrl_msg(adapter, SE 395 st5481_usb_device_ctrl_msg(adapter, SET_DEFAULT, 0, NULL, NULL);
396 } 396 }
397 397
398 /* =========================================== 398 /* ======================================================================
399 * isochronous USB helpers 399 * isochronous USB helpers
400 */ 400 */
401 401
402 static void 402 static void
403 fill_isoc_urb(struct urb *urb, struct usb_devi 403 fill_isoc_urb(struct urb *urb, struct usb_device *dev,
404 unsigned int pipe, void *buf, in 404 unsigned int pipe, void *buf, int num_packets,
405 int packet_size, usb_complete_t 405 int packet_size, usb_complete_t complete,
406 void *context) 406 void *context)
407 { 407 {
408 int k; 408 int k;
409 409
410 urb->dev=dev; 410 urb->dev=dev;
411 urb->pipe=pipe; 411 urb->pipe=pipe;
412 urb->interval = 1; 412 urb->interval = 1;
413 urb->transfer_buffer=buf; 413 urb->transfer_buffer=buf;
414 urb->number_of_packets = num_packets; 414 urb->number_of_packets = num_packets;
415 urb->transfer_buffer_length=num_packet 415 urb->transfer_buffer_length=num_packets*packet_size;
416 urb->actual_length = 0; 416 urb->actual_length = 0;
417 urb->complete=complete; 417 urb->complete=complete;
418 urb->context=context; 418 urb->context=context;
419 urb->transfer_flags=URB_ISO_ASAP; 419 urb->transfer_flags=URB_ISO_ASAP;
420 for (k = 0; k < num_packets; k++) { 420 for (k = 0; k < num_packets; k++) {
421 urb->iso_frame_desc[k].offset 421 urb->iso_frame_desc[k].offset = packet_size * k;
422 urb->iso_frame_desc[k].length 422 urb->iso_frame_desc[k].length = packet_size;
423 urb->iso_frame_desc[k].actual_ 423 urb->iso_frame_desc[k].actual_length = 0;
424 } 424 }
425 } 425 }
426 426
427 int 427 int
428 st5481_setup_isocpipes(struct urb* urb[2], str 428 st5481_setup_isocpipes(struct urb* urb[2], struct usb_device *dev,
429 unsigned int pipe, 429 unsigned int pipe, int num_packets,
430 int packet_size, in 430 int packet_size, int buf_size,
431 usb_complete_t comp 431 usb_complete_t complete, void *context)
432 { 432 {
433 int j, retval; 433 int j, retval;
434 unsigned char *buf; 434 unsigned char *buf;
435 435
436 for (j = 0; j < 2; j++) { 436 for (j = 0; j < 2; j++) {
437 retval = -ENOMEM; 437 retval = -ENOMEM;
438 urb[j] = usb_alloc_urb(num_pac 438 urb[j] = usb_alloc_urb(num_packets, GFP_KERNEL);
439 if (!urb[j]) 439 if (!urb[j])
440 goto err; 440 goto err;
441 441
442 // Allocate memory for 2000byt 442 // Allocate memory for 2000bytes/sec (16Kb/s)
443 buf = kmalloc(buf_size, GFP_KE 443 buf = kmalloc(buf_size, GFP_KERNEL);
444 if (!buf) 444 if (!buf)
445 goto err; 445 goto err;
446 446
447 // Fill the isochronous URB 447 // Fill the isochronous URB
448 fill_isoc_urb(urb[j], dev, pip 448 fill_isoc_urb(urb[j], dev, pipe, buf,
449 num_packets, pac 449 num_packets, packet_size, complete,
450 context); 450 context);
451 } 451 }
452 return 0; 452 return 0;
453 453
454 err: 454 err:
455 for (j = 0; j < 2; j++) { 455 for (j = 0; j < 2; j++) {
456 if (urb[j]) { 456 if (urb[j]) {
457 kfree(urb[j]->transfer 457 kfree(urb[j]->transfer_buffer);
458 urb[j]->transfer_buffe 458 urb[j]->transfer_buffer = NULL;
459 usb_free_urb(urb[j]); 459 usb_free_urb(urb[j]);
460 urb[j] = NULL; 460 urb[j] = NULL;
461 } 461 }
462 } 462 }
463 return retval; 463 return retval;
464 } 464 }
465 465
466 void st5481_release_isocpipes(struct urb* urb[ 466 void st5481_release_isocpipes(struct urb* urb[2])
467 { 467 {
468 int j; 468 int j;
469 469
470 for (j = 0; j < 2; j++) { 470 for (j = 0; j < 2; j++) {
471 usb_kill_urb(urb[j]); 471 usb_kill_urb(urb[j]);
472 kfree(urb[j]->transfer_buffer) 472 kfree(urb[j]->transfer_buffer);
473 usb_free_urb(urb[j]); 473 usb_free_urb(urb[j]);
474 urb[j] = NULL; 474 urb[j] = NULL;
475 } 475 }
476 } 476 }
477 477
478 /* 478 /*
479 * Decode frames received on the B/D channel. 479 * Decode frames received on the B/D channel.
480 * Note that this function will be called cont 480 * Note that this function will be called continously
481 * with 64Kbit/s / 16Kbit/s of data and hence 481 * with 64Kbit/s / 16Kbit/s of data and hence it will be
482 * called 50 times per second with 20 ISOC des 482 * called 50 times per second with 20 ISOC descriptors.
483 * Called at interrupt. 483 * Called at interrupt.
484 */ 484 */
485 static void usb_in_complete(struct urb *urb) 485 static void usb_in_complete(struct urb *urb)
486 { 486 {
487 struct st5481_in *in = urb->context; 487 struct st5481_in *in = urb->context;
488 unsigned char *ptr; 488 unsigned char *ptr;
489 struct sk_buff *skb; 489 struct sk_buff *skb;
490 int len, count, status; 490 int len, count, status;
491 491
492 if (unlikely(urb->status < 0)) { 492 if (unlikely(urb->status < 0)) {
493 switch (urb->status) { 493 switch (urb->status) {
494 case -ENOENT: 494 case -ENOENT:
495 case -ESHUTDOWN: 495 case -ESHUTDOWN:
496 case -ECONNRESET: 496 case -ECONNRESET:
497 DBG(1,"urb kil 497 DBG(1,"urb killed status %d", urb->status);
498 return; // Giv 498 return; // Give up
499 default: 499 default:
500 WARN("urb stat 500 WARN("urb status %d",urb->status);
501 break; 501 break;
502 } 502 }
503 } 503 }
504 504
505 DBG_ISO_PACKET(0x80,urb); 505 DBG_ISO_PACKET(0x80,urb);
506 506
507 len = st5481_isoc_flatten(urb); 507 len = st5481_isoc_flatten(urb);
508 ptr = urb->transfer_buffer; 508 ptr = urb->transfer_buffer;
509 while (len > 0) { 509 while (len > 0) {
510 if (in->mode == L1_MODE_TRANS) 510 if (in->mode == L1_MODE_TRANS) {
511 memcpy(in->rcvbuf, ptr 511 memcpy(in->rcvbuf, ptr, len);
512 status = len; 512 status = len;
513 len = 0; 513 len = 0;
514 } else { 514 } else {
515 status = isdnhdlc_deco 515 status = isdnhdlc_decode(&in->hdlc_state, ptr, len, &count,
516 in->rcvbuf, in 516 in->rcvbuf, in->bufsize);
517 ptr += count; 517 ptr += count;
518 len -= count; 518 len -= count;
519 } 519 }
520 520
521 if (status > 0) { 521 if (status > 0) {
522 // Good frame received 522 // Good frame received
523 DBG(4,"count=%d",statu 523 DBG(4,"count=%d",status);
524 DBG_PACKET(0x400, in-> 524 DBG_PACKET(0x400, in->rcvbuf, status);
525 if (!(skb = dev_alloc_ 525 if (!(skb = dev_alloc_skb(status))) {
526 WARN("receive 526 WARN("receive out of memory\n");
527 break; 527 break;
528 } 528 }
529 memcpy(skb_put(skb, st 529 memcpy(skb_put(skb, status), in->rcvbuf, status);
530 in->hisax_if->l1l2(in- 530 in->hisax_if->l1l2(in->hisax_if, PH_DATA | INDICATION, skb);
531 } else if (status == -HDLC_CRC 531 } else if (status == -HDLC_CRC_ERROR) {
532 INFO("CRC error"); 532 INFO("CRC error");
533 } else if (status == -HDLC_FRA 533 } else if (status == -HDLC_FRAMING_ERROR) {
534 INFO("framing error"); 534 INFO("framing error");
535 } else if (status == -HDLC_LEN 535 } else if (status == -HDLC_LENGTH_ERROR) {
536 INFO("length error"); 536 INFO("length error");
537 } 537 }
538 } 538 }
539 539
540 // Prepare URB for next transfer 540 // Prepare URB for next transfer
541 urb->dev = in->adapter->usb_dev; 541 urb->dev = in->adapter->usb_dev;
542 urb->actual_length = 0; 542 urb->actual_length = 0;
543 543
544 SUBMIT_URB(urb, GFP_ATOMIC); 544 SUBMIT_URB(urb, GFP_ATOMIC);
545 } 545 }
546 546
547 int st5481_setup_in(struct st5481_in *in) 547 int st5481_setup_in(struct st5481_in *in)
548 { 548 {
549 struct usb_device *dev = in->adapter-> 549 struct usb_device *dev = in->adapter->usb_dev;
550 int retval; 550 int retval;
551 551
552 DBG(4,""); 552 DBG(4,"");
553 553
554 in->rcvbuf = kmalloc(in->bufsize, GFP_ 554 in->rcvbuf = kmalloc(in->bufsize, GFP_KERNEL);
555 retval = -ENOMEM; 555 retval = -ENOMEM;
556 if (!in->rcvbuf) 556 if (!in->rcvbuf)
557 goto err; 557 goto err;
558 558
559 retval = st5481_setup_isocpipes(in->ur 559 retval = st5481_setup_isocpipes(in->urb, dev,
560 usb_rc 560 usb_rcvisocpipe(dev, in->ep),
561 in->nu 561 in->num_packets, in->packet_size,
562 in->nu 562 in->num_packets * in->packet_size,
563 usb_in 563 usb_in_complete, in);
564 if (retval) 564 if (retval)
565 goto err_free; 565 goto err_free;
566 return 0; 566 return 0;
567 567
568 err_free: 568 err_free:
569 kfree(in->rcvbuf); 569 kfree(in->rcvbuf);
570 err: 570 err:
571 return retval; 571 return retval;
572 } 572 }
573 573
574 void st5481_release_in(struct st5481_in *in) 574 void st5481_release_in(struct st5481_in *in)
575 { 575 {
576 DBG(2,""); 576 DBG(2,"");
577 577
578 st5481_release_isocpipes(in->urb); 578 st5481_release_isocpipes(in->urb);
579 } 579 }
580 580
581 /* 581 /*
582 * Make the transfer_buffer contiguous by 582 * Make the transfer_buffer contiguous by
583 * copying from the iso descriptors if necessa 583 * copying from the iso descriptors if necessary.
584 */ 584 */
585 static int st5481_isoc_flatten(struct urb *urb 585 static int st5481_isoc_flatten(struct urb *urb)
586 { 586 {
587 struct usb_iso_packet_descriptor *pipd 587 struct usb_iso_packet_descriptor *pipd,*pend;
588 unsigned char *src,*dst; 588 unsigned char *src,*dst;
589 unsigned int len; 589 unsigned int len;
590 590
591 if (urb->status < 0) { 591 if (urb->status < 0) {
592 return urb->status; 592 return urb->status;
593 } 593 }
594 for (pipd = &urb->iso_frame_desc[0], 594 for (pipd = &urb->iso_frame_desc[0],
595 pend = &urb->iso_frame_de 595 pend = &urb->iso_frame_desc[urb->number_of_packets],
596 dst = urb->transfer_buffe 596 dst = urb->transfer_buffer;
597 pipd < pend; 597 pipd < pend;
598 pipd++) { 598 pipd++) {
599 599
600 if (pipd->status < 0) { 600 if (pipd->status < 0) {
601 return (pipd->status); 601 return (pipd->status);
602 } 602 }
603 603
604 len = pipd->actual_length; 604 len = pipd->actual_length;
605 pipd->actual_length = 0; 605 pipd->actual_length = 0;
606 src = urb->transfer_buffer+pip 606 src = urb->transfer_buffer+pipd->offset;
607 607
608 if (src != dst) { 608 if (src != dst) {
609 // Need to copy since 609 // Need to copy since isoc buffers not full
610 while (len--) { 610 while (len--) {
611 *dst++ = *src+ 611 *dst++ = *src++;
612 } 612 }
613 } else { 613 } else {
614 // No need to copy, ju 614 // No need to copy, just update destination buffer
615 dst += len; 615 dst += len;
616 } 616 }
617 } 617 }
618 // Return size of flattened buffer 618 // Return size of flattened buffer
619 return (dst - (unsigned char *)urb->tr 619 return (dst - (unsigned char *)urb->transfer_buffer);
620 } 620 }
621 621
622 static void st5481_start_rcv(void *context) 622 static void st5481_start_rcv(void *context)
623 { 623 {
624 struct st5481_in *in = context; 624 struct st5481_in *in = context;
625 struct st5481_adapter *adapter = in->a 625 struct st5481_adapter *adapter = in->adapter;
626 626
627 DBG(4,""); 627 DBG(4,"");
628 628
629 in->urb[0]->dev = adapter->usb_dev; 629 in->urb[0]->dev = adapter->usb_dev;
630 SUBMIT_URB(in->urb[0], GFP_KERNEL); 630 SUBMIT_URB(in->urb[0], GFP_KERNEL);
631 631
632 in->urb[1]->dev = adapter->usb_dev; 632 in->urb[1]->dev = adapter->usb_dev;
633 SUBMIT_URB(in->urb[1], GFP_KERNEL); 633 SUBMIT_URB(in->urb[1], GFP_KERNEL);
634 } 634 }
635 635
636 void st5481_in_mode(struct st5481_in *in, int 636 void st5481_in_mode(struct st5481_in *in, int mode)
637 { 637 {
638 if (in->mode == mode) 638 if (in->mode == mode)
639 return; 639 return;
640 640
641 in->mode = mode; 641 in->mode = mode;
642 642
643 usb_unlink_urb(in->urb[0]); 643 usb_unlink_urb(in->urb[0]);
644 usb_unlink_urb(in->urb[1]); 644 usb_unlink_urb(in->urb[1]);
645 645
646 if (in->mode != L1_MODE_NULL) { 646 if (in->mode != L1_MODE_NULL) {
647 if (in->mode != L1_MODE_TRANS) 647 if (in->mode != L1_MODE_TRANS)
648 isdnhdlc_rcv_init(&in- 648 isdnhdlc_rcv_init(&in->hdlc_state,
649 in->mode == L1 649 in->mode == L1_MODE_HDLC_56K);
650 650
651 st5481_usb_pipe_reset(in->adap 651 st5481_usb_pipe_reset(in->adapter, in->ep, NULL, NULL);
652 st5481_usb_device_ctrl_msg(in- 652 st5481_usb_device_ctrl_msg(in->adapter, in->counter,
653 in- 653 in->packet_size,
654 NUL 654 NULL, NULL);
655 st5481_start_rcv(in); 655 st5481_start_rcv(in);
656 } else { 656 } else {
657 st5481_usb_device_ctrl_msg(in- 657 st5481_usb_device_ctrl_msg(in->adapter, in->counter,
658 0, 658 0, NULL, NULL);
659 } 659 }
660 } 660 }
661 661
662 662
|
This page was automatically generated by the
LXR engine.
|