drivers/usb/ohci-hcd.c

Name: Public Git Hosting - davej-history.git/blob - drivers/usb/ohci-hcd.c
Rating: 4.5 (9902 reviews)
 1 /*
 2  * OHCI HCD (Host Controller Driver) for USB.
 3  *
 4  * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
 5  *
 6  * The OHCI HCD layer is a simple but nearly complete implementation of what
 7  * the USB people would call a HCD for the OHCI.
 8  * (ISO alpha , Bulk, INT u. CTRL transfers enabled)
 9  * The layer on top of it, is for interfacing to the alternate-usb
 10  * device-drivers.
 11  *
 12  * [ This is based on Linus' UHCI code and gregs OHCI fragments
 13  * (0.03c source tree). ]
 14  * [ Open Host Controller Interface driver for USB. ]
 15  * [ (C) Copyright 1999 Linus Torvalds (uhci.c) ]
 16  * [ (C) Copyright 1999 Gregory P. Smith <greg@electricrain.com> ]
 17  * [ $Log: ohci.c,v $ ]
 18  * [ Revision 1.1 1999/04/05 08:32:30 greg ]
 19  *
 20  * v4.2 1999/09/05 ISO API alpha, new dev alloc, neg Error-codes
 21  * v4.1 1999/08/27 Randy Dunlap's - ISO API first impl.
 22  * v4.0 1999/08/18
 23  * v3.0 1999/06/25
 24  * v2.1 1999/05/09 code clean up
 25  * v2.0 1999/05/04
 26  * virtual root hub is now enabled,
 27  * memory allocation based on kmalloc and kfree now, Bus error handling,
 28  * INT, CTRL and BULK transfers enabled, ISO needs testing (alpha)
 29  *
 30  * from Linus Torvalds (uhci.c) (APM not tested; hub, usb_device, bus and related stuff)
 31  * from Greg Smith (ohci.c) (reset controller handling, hub)
 32  *
 33  * v1.0 1999/04/27 initial release
 34  * ohci-hcd.c
 35  */
 36
 37
 38
 39 #include <linux/config.h>
 40 #include <linux/module.h>
 41 #include <linux/pci.h>
 42 #include <linux/kernel.h>
 43 #include <linux/delay.h>
 44 #include <linux/ioport.h>
 45 #include <linux/sched.h>
 46 #include <linux/malloc.h>
 47 #include <linux/smp_lock.h>
 48 #include <linux/errno.h>
 49 #include <linux/timer.h>
 50 #include <linux/spinlock.h>
 51
 52 #include <asm/io.h>
 53 #include <asm/irq.h>
 54 #include <asm/system.h>
 55
 56 #include"usb.h"
 57 #include"ohci-hcd.h"
 58
 59 #ifdef CONFIG_APM
 60 #include <linux/apm_bios.h>
 61 static inthandle_apm_event(apm_event_t event);
 62 static int apm_resume =0;
 63 #endif
 64
 65 static intohci_link_ed(struct ohci * ohci,struct usb_ohci_ed *ed);
 66 static intsohci_kill_isoc(struct usb_isoc_desc *id);
 67 static intsohci_get_current_frame_number(struct usb_device *usb_dev);
 68 static intsohci_run_isoc(struct usb_isoc_desc *id,struct usb_isoc_desc *pr_id);
 69 staticDECLARE_WAIT_QUEUE_HEAD(op_wakeup);
 70
 71 voidusb_pipe_to_hcd_ed(struct usb_device *usb_dev,unsigned int pipe,struct usb_hcd_ed *hcd_ed)
 72 {
 73  hcd_ed->endpoint =usb_pipeendpoint(pipe);
 74  hcd_ed->out =usb_pipeout(pipe);
 75  hcd_ed->function =usb_pipedevice(pipe);
 76  hcd_ed->type =usb_pipetype(pipe);
 77  hcd_ed->slow =usb_pipeslow(pipe);
 78  hcd_ed->maxpack =usb_maxpacket(usb_dev, pipe,usb_pipeout(pipe));
 79 OHCI_DEBUG(printk("******* hcd_ed: pipe: %8x, endpoint: %4x, function: %4x, out: %4x, type: %4x, slow: %4x, maxpack: %4x\n", pipe, hcd_ed->endpoint, hcd_ed->function, hcd_ed->out, hcd_ed->type, hcd_ed->slow, hcd_ed->maxpack); )
 80 OHCI_DEBUG(printk("******* dev: devnum: %4x, slow: %4x, maxpacketsize: %4x\n",usb_dev->devnum, usb_dev->slow, usb_dev->maxpacketsize); )
 81 }
 82
 83
 84 /********
 85  **** Interface functions
 86  ***********************************************/
 87
 88 static intsohci_blocking_handler(void* ohci_in,struct usb_ohci_ed *ed,void* data,int data_len,int status, __OHCI_BAG lw0, __OHCI_BAG lw1)
 89 {
 90 if(lw0 != NULL) {
 91 if(USB_ST_CRC <0&& (status == USB_ST_DATAUNDERRUN || status == USB_ST_NOERROR))
 92 ((struct ohci_state * )lw0)->status = data_len;
 93 else
 94 ((struct ohci_state * )lw0)->status = status;
 95 ((struct ohci_state * )lw0)->len = data_len;
 96 }
 97 if(lw1 != NULL) {
 98 add_wait_queue(&op_wakeup, lw1);
 99 wake_up(&op_wakeup);
 100 }
 101
 102 OHCI_DEBUG( {int i;printk("USB HC bh <<<: %x: ", ed->hwINFO);)
 103 OHCI_DEBUG(printk(" data(%d):", data_len);)
 104 OHCI_DEBUG(for(i=0; i < data_len; i++ )printk(" %02x", ((__u8 *) data)[i]);)
 105 OHCI_DEBUG(printk(" ret_status: %x\n", status); })
 106
 107 return0;
 108 }
 109
 110 static intsohci_int_handler(void* ohci_in,struct usb_ohci_ed *ed,void* data,int data_len,int status, __OHCI_BAG lw0, __OHCI_BAG lw1)
 111 {
 112
 113 struct ohci * ohci = ohci_in;
 114  usb_device_irq handler=(void*) lw0;
 115 void*dev_id = (void*) lw1;
 116 int ret;
 117
 118 OHCI_DEBUG({int i;printk("USB HC IRQ <<<: %x: data(%d):", ed->hwINFO, data_len);)
 119 OHCI_DEBUG(for(i=0; i < data_len; i++ )printk(" %02x", ((__u8 *) data)[i]);)
 120 OHCI_DEBUG(printk(" ret_status: %x\n", status); })
 121
 122  ret =handler(status, data, data_len, dev_id);
 123 if(ret ==0)return0;/* 0 .. do not requeue */
 124 if(status >0)return-1;/* error occured do not requeue ? */
 125 ohci_trans_req(ohci, ed,0, NULL, data, (ed->hwINFO >>16) &0x3f, (__OHCI_BAG) handler, (__OHCI_BAG) dev_id, INT_IN, sohci_int_handler);/* requeue int request */
 126
 127 return0;
 128 }
 129
 130 static intsohci_iso_handler(void* ohci_in,struct usb_ohci_ed *ed,void* data,int data_len,int status, __OHCI_BAG lw0, __OHCI_BAG lw1) {
 131
 132 // struct ohci * ohci = ohci_in;
 133 unsigned int ix = (unsigned int) lw0;
 134 struct usb_isoc_desc * id = (struct usb_isoc_desc *) lw1;
 135 struct usb_ohci_td **tdp = id->td;
 136 int ret =0;
 137 int fx;
 138
 139 OHCI_DEBUG({int i;printk("USB HC ISO |||: %x: data(%d):", ed->hwINFO, data_len);)
 140 OHCI_DEBUG(for(i=0; i <16; i++ )printk(" %02x", ((__u8 *) data)[i]);)
 141 OHCI_DEBUG(printk(" ... ret_status: %x\n", status); })
 142
 143  tdp[ix] = NULL;
 144  id->frames[ix].frame_length = data_len;
 145  id->frames[ix].frame_status = status;
 146  id->total_length += data_len;
 147 if(status) id->error_count++;
 148
 149  id->cur_completed_frame++;
 150  id->total_completed_frames++;
 151
 152 if(id->cur_completed_frame == id->callback_frames) {
 153  id->prev_completed_frame = id->cur_completed_frame;
 154  id->cur_completed_frame =0;
 155 OHCI_DEBUG(printk("USB HC ISO <<<: %x:\n", ed->hwINFO);)
 156  ret = id->callback_fn(id->error_count, id->data, id->total_length, id);
 157 switch(ret) {
 158 case CB_CONT_RUN:
 159 for(fx =0; fx < id->frame_count; fx++)
 160  id->frames[fx].frame_length = id->frame_size;
 161 sohci_run_isoc(id, id->prev_isocdesc);
 162 break;
 163
 164 case CB_CONTINUE:
 165 break;
 166
 167 case CB_REUSE:
 168 break;
 169
 170 case CB_RESTART:
 171 break;
 172
 173 case CB_ABORT:
 174 sohci_kill_isoc(id);
 175 break;
 176 }
 177 }
 178
 179 return0;
 180 }
 181
 182 static void*sohci_request_irq(struct usb_device *usb_dev,unsigned int pipe, usb_device_irq handler,int period,void*dev_id)
 183 {
 184 struct ohci * ohci = usb_dev->bus->hcpriv;
 185 struct ohci_device * dev =usb_to_ohci(usb_dev);
 186 struct usb_hcd_ed hcd_ed;
 187 struct usb_ohci_ed * ed;
 188
 189 #ifdef VROOTHUB
 190 if(usb_pipedevice(pipe) == ohci->rh.devnum)
 191 returnroot_hub_request_irq(usb_dev, pipe, handler, period, dev_id);
 192 #endif
 193
 194 usb_pipe_to_hcd_ed(usb_dev, pipe, &hcd_ed);
 195  hcd_ed.type = INT;
 196  ed =usb_ohci_add_ep(usb_dev, &hcd_ed, period,1);
 197
 198 OHCI_DEBUG(printk("USB HC IRQ>>>: %x: every %d ms\n", ed->hwINFO, period);)
 199
 200 ohci_trans_req(ohci, ed,0, NULL, dev->data, hcd_ed.maxpack, (__OHCI_BAG) handler, (__OHCI_BAG) dev_id, INT_IN, sohci_int_handler);
 201 if(ED_STATE(ed) != ED_OPER)ohci_link_ed(ohci, ed);
 202 return ed;
 203
 204 }
 205
 206 static intsohci_release_irq(struct usb_device *usb_dev,void* ed)
 207 {
 208 // struct usb_device *usb_dev = ((struct ohci_device *) ((unsigned int)ed & 0xfffff000))->usb;
 209 struct ohci * ohci = usb_dev->bus->hcpriv;
 210
 211 OHCI_DEBUG(printk("USB HC ***** RM_IRQ>>>:%4x\n", (unsigned int) ed);)
 212
 213 if(ed == NULL)return0;
 214
 215 #ifdef VROOTHUB
 216 if(ed == ohci->rh.int_addr)
 217 returnroot_hub_release_irq(usb_dev, ed);
 218 #endif
 219 ED_setSTATE((struct usb_ohci_ed *)ed, ED_STOP);
 220
 221 usb_ohci_rm_ep(usb_dev, (struct usb_ohci_ed *) ed, NULL, NULL, NULL,0);
 222
 223 return0;
 224 }
 225
 226 static intsohci_control_msg(struct usb_device *usb_dev,unsigned int pipe, devrequest *cmd,void*data,int len)
 227 {
 228 DECLARE_WAITQUEUE(wait, current);
 229 struct ohci_state state = {0, TD_NOTACCESSED};
 230 struct ohci * ohci = usb_dev->bus->hcpriv;
 231 struct usb_hcd_ed hcd_ed;
 232 struct usb_ohci_ed *ed;
 233
 234 #ifdef VROOTHUB
 235 if(usb_pipedevice(pipe) == ohci->rh.devnum)
 236 returnroot_hub_control_msg(usb_dev, pipe, cmd, data, len);
 237 #endif
 238
 239 usb_pipe_to_hcd_ed(usb_dev, pipe, &hcd_ed);
 240  hcd_ed.type = CTRL;
 241
 242  ed =usb_ohci_add_ep(usb_dev, &hcd_ed,0,1);
 243
 244 OHCI_DEBUG( {int i;printk("USB HC CTRL>>>: ed:%x-%x: ctrl(%d):", (unsigned int) ed, ed->hwINFO,8);)
 245 OHCI_DEBUG(for(i=0; i <8; i++ )printk(" %02x", ((__u8 *) cmd)[i]);)
 246 OHCI_DEBUG(printk(" data(%d):", len);)
 247 OHCI_DEBUG(for(i=0; i < len; i++ )printk(" %02x", ((__u8 *) data)[i]);)
 248 OHCI_DEBUG(printk("\n"); })
 249  current->state = TASK_UNINTERRUPTIBLE;
 250
 251 ohci_trans_req(ohci, ed,8, cmd, data, len, (__OHCI_BAG) &state, (__OHCI_BAG) &wait, (usb_pipeout(pipe))?CTRL_OUT:CTRL_IN, sohci_blocking_handler);
 252
 253 OHCI_DEBUG(printk("USB HC trans req ed %x: %x :", ed->hwINFO, (unsigned int) ed); )
 254 OHCI_DEBUG({int i;for( i=0; i<8;i++)printk(" %4x", ((unsigned int*) ed)[i]) ;printk("\n"); }; )
 255 if(ED_STATE(ed) != ED_OPER)ohci_link_ed(ohci, ed);
 256 schedule_timeout(HZ*5);
 257
 258 if(state.status == TD_NOTACCESSED) {
 259  current->state = TASK_UNINTERRUPTIBLE;
 260 usb_ohci_rm_ep(usb_dev, ed, sohci_blocking_handler, NULL, NULL,0);
 261 schedule();
 262  state.status = USB_ST_TIMEOUT;
 263 }
 264 remove_wait_queue(&op_wakeup, &wait);
 265 return state.status;
 266 }
 267
 268 static intsohci_bulk_msg(struct usb_device *usb_dev,unsigned int pipe,void*data,int len,unsigned long*rval)
 269 {
 270 DECLARE_WAITQUEUE(wait, current);
 271 struct ohci_state state = {0, TD_NOTACCESSED};
 272 struct ohci * ohci = usb_dev->bus->hcpriv;
 273 struct usb_hcd_ed hcd_ed;
 274 struct usb_ohci_ed *ed;
 275
 276 usb_pipe_to_hcd_ed(usb_dev, pipe, &hcd_ed);
 277  hcd_ed.type = BULK;
 278  ed =usb_ohci_add_ep(usb_dev, &hcd_ed,0,1);
 279 OHCI_DEBUG( {int i;printk("USB HC BULK>>>: %x: ", ed->hwINFO);)
 280 OHCI_DEBUG(printk(" data(%d):", len);)
 281 OHCI_DEBUG(for(i=0; i < len; i++ )printk(" %02x", ((__u8 *) data)[i]);)
 282 OHCI_DEBUG(printk("\n"); })
 283  current->state = TASK_UNINTERRUPTIBLE;
 284
 285 ohci_trans_req(ohci, ed,0, NULL, data, len, (__OHCI_BAG) &state, (__OHCI_BAG) &wait,(usb_pipeout(pipe))?BULK_OUT:BULK_IN, sohci_blocking_handler);
 286 if(ED_STATE(ed) != ED_OPER)ohci_link_ed(ohci, ed);
 287
 288 schedule_timeout(HZ*5);
 289
 290 if(state.status == TD_NOTACCESSED) {
 291  current->state = TASK_UNINTERRUPTIBLE;
 292 usb_ohci_rm_ep(usb_dev, ed, sohci_blocking_handler, NULL, NULL,0);
 293 schedule();
 294  state.status = USB_ST_TIMEOUT;
 295 }
 296 remove_wait_queue(&op_wakeup, &wait);
 297 *rval = state.len;
 298 return state.status;
 299 }
 300
 301 static void*sohci_request_bulk(struct usb_device *usb_dev,unsigned int pipe, usb_device_irq handler,void*data,int len,void*dev_id)
 302 {
 303 struct ohci * ohci = usb_dev->bus->hcpriv;
 304 struct usb_hcd_ed hcd_ed;
 305 struct usb_ohci_ed * ed;
 306
 307 usb_pipe_to_hcd_ed(usb_dev, pipe, &hcd_ed);
 308  hcd_ed.type = BULK;
 309  ed =usb_ohci_add_ep(usb_dev, &hcd_ed,0,1);
 310
 311 OHCI_DEBUG(printk("USB HC BULK_RQ>>>: %x\n", ed->hwINFO);)
 312
 313 ohci_trans_req(ohci, ed,0, NULL, data, len, (__OHCI_BAG) handler, (__OHCI_BAG) dev_id, (usb_pipeout(pipe))?BULK_OUT:BULK_IN, sohci_int_handler);
 314 if(ED_STATE(ed) != ED_OPER)ohci_link_ed(ohci, ed);
 315
 316 return ed;
 317 }
 318
 319 static intsohci_terminate_bulk(struct usb_device *usb_dev,void* ed)
 320 {
 321 DECLARE_WAITQUEUE(wait, current);
 322
 323 OHCI_DEBUG(printk("USB HC TERM_BULK>>>:%4x\n", (unsigned int) ed);)
 324
 325  current->state = TASK_UNINTERRUPTIBLE;
 326 usb_ohci_rm_ep(usb_dev, (struct usb_ohci_ed *) ed, sohci_blocking_handler, NULL, &wait, SEND);
 327 schedule();
 328 remove_wait_queue(&op_wakeup, &wait);
 329 return1;
 330 }
 331
 332 static intsohci_alloc_dev(struct usb_device *usb_dev)
 333 {
 334 struct ohci_device *dev;
 335
 336 /* Allocate the OHCI_HCD device private data */
 337  dev =kmalloc(sizeof(*dev), GFP_KERNEL);
 338 if(!dev)
 339 return-1;
 340
 341 /* Initialize "dev" */
 342 memset(dev,0,sizeof(*dev));
 343
 344  usb_dev->hcpriv = dev;
 345  dev->usb = usb_dev;
 346 atomic_set(&dev->refcnt,1);
 347
 348 if(usb_dev->parent)
 349  dev->ohci =usb_to_ohci(usb_dev->parent)->ohci;
 350
 351 return0;
 352 }
 353
 354 static intsohci_free_dev(struct usb_device *usb_dev)
 355 {
 356 int cnt;
 357 DECLARE_WAITQUEUE(wait, current);
 358 struct ohci_device *dev =usb_to_ohci(usb_dev);
 359
 360 OHCI_DEBUG(printk("USB HC ***** free %x\n", usb_dev->devnum);)
 361
 362 if(usb_dev->devnum >=0) {
 363  current->state = TASK_UNINTERRUPTIBLE;
 364  cnt =usb_ohci_rm_function(usb_dev, sohci_blocking_handler, NULL, &wait);
 365 if(cnt >0) {
 366 schedule();
 367 remove_wait_queue(&op_wakeup, &wait);
 368 }
 369  current->state = TASK_INTERRUPTIBLE;
 370 }
 371
 372 if(atomic_dec_and_test(&dev->refcnt))
 373 kfree(dev);
 374
 375 return0;
 376 }
 377
 378
 379
 380 /*
 381  * ISO Interface designed by Randy Dunlap
 382  */
 383
 384 static intsohci_get_current_frame_number(struct usb_device *usb_dev) {
 385
 386 struct ohci * ohci = usb_dev->bus->hcpriv;
 387
 388 returnreadl(&ohci->regs->fmnumber) &0xffff;
 389 }
 390
 391
 392 static intsohci_init_isoc(struct usb_device *usb_dev,unsigned int pipe,int frame_count,void*context,struct usb_isoc_desc **idp) {
 393
 394 struct usb_isoc_desc *id;
 395
 396 *idp = NULL;
 397
 398  id =kmalloc(sizeof(struct usb_isoc_desc) + (sizeof(struct isoc_frame_desc) * frame_count), GFP_KERNEL);
 399 if(!id)return-ENOMEM;
 400 memset(id,0,sizeof(struct usb_isoc_desc) + (sizeof(struct isoc_frame_desc) * frame_count));
 401 OHCI_DEBUG(printk("ISO alloc id: %p, size: %d\n", id,sizeof(struct usb_isoc_desc) + (sizeof(struct isoc_frame_desc) * frame_count));)
 402  id->td =kmalloc(sizeof(void*) * frame_count, GFP_KERNEL);
 403 if(!id->td) {
 404 kfree(id);
 405 return-ENOMEM;
 406 }
 407 memset(id->td,0,sizeof(void*) * frame_count);
 408 OHCI_DEBUG(printk("ISO alloc id->td: %p, size: %d\n", id->td,sizeof(void*) * frame_count);)
 409
 410  id->frame_count = frame_count;
 411  id->frame_size =usb_maxpacket(usb_dev, pipe,usb_pipeout(pipe));
 412  id->start_frame = -1;
 413  id->end_frame = -1;
 414  id->usb_dev = usb_dev;
 415  id->pipe = pipe;
 416  id->context = context;
 417
 418 *idp = id;
 419 return0;
 420 }
 421
 422 voidprint_int_eds(struct ohci * ohci);
 423
 424 static intsohci_run_isoc(struct usb_isoc_desc *id,struct usb_isoc_desc *pr_id) {
 425
 426 struct ohci * ohci = id->usb_dev->bus->hcpriv;
 427 struct usb_ohci_td ** tdp = (struct usb_ohci_td **) id->td;
 428 struct usb_hcd_ed hcd_ed;
 429 struct usb_ohci_ed * ed;
 430 int ix, frlen;
 431 unsigned char*bufptr;
 432
 433 if(pr_id)
 434  id->start_frame = pr_id->end_frame +1;
 435 else{
 436 switch(id->start_type) {
 437 case START_ABSOLUTE:
 438 break;
 439
 440 case START_RELATIVE:
 441 if(id->start_frame < START_FRAME_FUDGE) id->start_frame = START_FRAME_FUDGE;
 442  id->start_frame +=sohci_get_current_frame_number(id->usb_dev);
 443 break;
 444
 445 case START_ASAP:
 446  id->start_frame = START_FRAME_FUDGE +sohci_get_current_frame_number(id->usb_dev);
 447 break;
 448 }
 449 }
 450
 451  id->start_frame &=0xffff;
 452  id->end_frame = (id->start_frame + id->frame_count -1) &0xffff;
 453
 454  id->prev_completed_frame =0;
 455  id->cur_completed_frame =0;
 456 if(id->frame_spacing <=0) id->frame_spacing =1;
 457
 458  bufptr = id->data;
 459
 460 usb_pipe_to_hcd_ed(id->usb_dev, id->pipe, &hcd_ed);
 461  hcd_ed.type = ISO;
 462  ed =usb_ohci_add_ep(id->usb_dev, &hcd_ed,1,1);
 463 OHCI_DEBUG(printk("USB HC ISO>>>: ed: %x-%x: (%d tds)\n", (unsigned int) ed, ed->hwINFO, id->frame_count);)
 464
 465 for(ix =0; ix < id->frame_count; ix++) {
 466  frlen = (id->frames[ix].frame_length > id->frame_size)? id->frame_size : id->frames[ix].frame_length;
 467 printk("ISO run id->td: %p\n", &tdp[ix]);
 468  tdp[ix] =ohci_trans_req(ohci, ed, id->start_frame + ix , NULL, bufptr, frlen, (__OHCI_BAG) ix, (__OHCI_BAG) id,
 469 (usb_pipeout(id->pipe))?ISO_OUT:ISO_IN,
 470  sohci_iso_handler);
 471  bufptr += frlen;
 472 }
 473
 474 if(ED_STATE(ed) != ED_OPER)ohci_link_ed(ohci, ed);
 475 print_int_eds(ohci);
 476 return0;
 477 }
 478
 479 static intsohci_kill_isoc(struct usb_isoc_desc *id) {
 480
 481 struct usb_ohci_ed *ed = NULL;
 482 struct usb_ohci_td **td = id->td;
 483 int i;
 484 printk("KILL_ISOC***:\n");
 485 for(i =0; i < id->frame_count; i++) {
 486 if(td[i]) {
 487  td[i]->type |= DEL;
 488  ed = td[i]->ed;printk(" %d", i);
 489 }
 490 }
 491 if(ed)usb_ohci_rm_ep(id->usb_dev, ed, NULL, NULL, NULL, TD_RM);
 492 printk(": end KILL_ISOC***: %p\n", ed);
 493  id->start_frame = -1;
 494 return0;
 495 }
 496
 497
 498 static voidsohci_free_isoc(struct usb_isoc_desc *id) {
 499 printk("FREE_ISOC***\n");
 500 wait_ms(2000);
 501 if(id->start_frame >=0)sohci_kill_isoc(id);
 502 printk("FREE_ISOC2***\n");
 503 wait_ms(2000);
 504 kfree(id->td);
 505 kfree(id);
 506 printk("FREE_ISOC3***\n");
 507 wait_ms(2000);
 508 }
 509
 510 struct usb_operations sohci_device_operations = {
 511  sohci_alloc_dev,
 512  sohci_free_dev,
 513  sohci_control_msg,
 514  sohci_bulk_msg,
 515  sohci_request_irq,
 516  sohci_release_irq,
 517  sohci_request_bulk,
 518  sohci_terminate_bulk,
 519  sohci_get_current_frame_number,
 520  sohci_init_isoc,
 521  sohci_free_isoc,
 522  sohci_run_isoc,
 523  sohci_kill_isoc
 524 };
 525
 526
 527 /******
 528  *** ED handling functions
 529  ************************************/
 530
 531 /* just for debugging; prints all 32 branches of the int ed tree inclusive iso eds*/
 532 voidprint_int_eds(struct ohci * ohci) {int i; __u32 * ed_p;
 533 for(i=0; i <32; i++) {
 534 OHCI_DEBUG(printk("branch int %2d(%2x): ", i,i); )
 535  ed_p = &(ohci->hc_area->hcca.int_table[i]);
 536 while(*ed_p !=0) {
 537 OHCI_DEBUG(printk("ed: %4x; ", (((struct usb_ohci_ed *)bus_to_virt(*ed_p))->hwINFO));)
 538  ed_p = &(((struct usb_ohci_ed *)bus_to_virt(*ed_p))->hwNextED);
 539 }
 540 OHCI_DEBUG(printk("\n");)
 541 }
 542 }
 543
 544 /*
 545  * search for the right branch to insert an interrupt ed into the int tree
 546  * do some load ballancing
 547  * returns the branch and
 548  * sets the interval to interval = 2^integer(ld(interval))
 549  * */
 550
 551 static intusb_ohci_int_ballance(struct ohci * ohci,int* interval,int load) {
 552
 553 int i,j;
 554
 555  j =0;/* search for the least loaded interrupt endpoint branch of all 32 branches */
 556 for(i=0; i<32; i++)if(ohci->ohci_int_load[j] > ohci->ohci_int_load[i]) j=i;
 557
 558 for(i=0; ((*interval >> i) >1) && (i <5); i++ );/* interval = 2^int(ld(interval)) */
 559 *interval =1<< i;
 560
 561  j = j % (*interval);
 562 for(i=j; i<32; i+=(*interval)) ohci->ohci_int_load[i] += load;
 563
 564
 565 OHCI_DEBUG(printk("USB HC new int ed on pos %d of interval %d\n",j, *interval);)
 566
 567 return j;
 568 }
 569
 570 /* the int tree is a binary tree
 571  * in order to process it sequentially the indexes of the branches have to be mapped
 572  * the mapping reverses the bits of a word of num_bits length
 573  * */
 574 static intrev(int num_bits,int word) {
 575 int i;
 576 int wout =0;
 577
 578 for(i =0; i < num_bits; i++) wout |= (((word >> i) &1) << (num_bits - i -1));
 579 return wout;
 580 }
 581
 582 /* get the ed from the endpoint / usb_device address */
 583
 584 struct usb_ohci_ed *ohci_find_ep(struct usb_device *usb_dev,struct usb_hcd_ed *hcd_ed) {
 585 return&(usb_to_ohci(usb_dev)->ed[(hcd_ed->endpoint <<1) | ((hcd_ed->type == CTRL)?0:hcd_ed->out)]);
 586 }
 587
 588 /* link an ed into one of the HC chains */
 589 static intohci_link_ed(struct ohci * ohci,struct usb_ohci_ed *ed) {
 590
 591 int int_branch;
 592 int i;
 593 int inter;
 594 int interval;
 595 int load;
 596  __u32 * ed_p;
 597
 598 ED_setSTATE(ed, ED_OPER);
 599
 600 switch(ED_TYPE(ed)) {
 601 case CTRL:
 602  ed->hwNextED =0;
 603 if(ohci->ed_controltail == NULL) {
 604 writel(virt_to_bus(ed), &ohci->regs->ed_controlhead);
 605 }
 606 else{
 607  ohci->ed_controltail->hwNextED =virt_to_bus(ed);
 608 }
 609  ed->ed_prev = ohci->ed_controltail;
 610  ohci->ed_controltail = ed;
 611 break;
 612
 613 case BULK:
 614  ed->hwNextED =0;
 615 if(ohci->ed_bulktail == NULL) {
 616 writel(virt_to_bus(ed), &ohci->regs->ed_bulkhead);
 617 }
 618 else{
 619  ohci->ed_bulktail->hwNextED =virt_to_bus(ed);
 620 }
 621  ed->ed_prev = ohci->ed_bulktail;
 622  ohci->ed_bulktail = ed;
 623 break;
 624
 625 case INT:
 626  interval = ed->int_period;
 627  load = ed->int_load;
 628  int_branch =usb_ohci_int_ballance(ohci, &interval, load);
 629  ed->int_interval = interval;
 630  ed->int_branch = int_branch;
 631
 632 for( i=0; i <rev(6, interval); i += inter) {
 633  inter =1;
 634 for(ed_p = &(ohci->hc_area->hcca.int_table[rev(5,i)+int_branch]);
 635 (*ed_p !=0) && (((struct usb_ohci_ed *)bus_to_virt(*ed_p))->int_interval >= interval);
 636  ed_p = &(((struct usb_ohci_ed *)bus_to_virt(*ed_p))->hwNextED))
 637  inter =rev(6,((struct usb_ohci_ed *)bus_to_virt(*ed_p))->int_interval);
 638  ed->hwNextED = *ed_p;
 639 *ed_p =virt_to_bus(ed);
 640 OHCI_DEBUG(printk("int_link i: %2x, inter: %2x, ed: %4x\n", i, inter, ed->hwINFO);)
 641 }
 642 break;
 643
 644 case ISO:
 645 if(ohci->ed_isotail != NULL) {
 646  ohci->ed_isotail->hwNextED =virt_to_bus(ed);
 647  ed->ed_prev = ohci->ed_isotail;
 648 }
 649 else{
 650 for( i=0; i <32; i += inter) {
 651  inter =1;
 652 for(ed_p = &(ohci->hc_area->hcca.int_table[rev(5,i)]);
 653 *ed_p !=0;
 654  ed_p = &(((struct usb_ohci_ed *)bus_to_virt(*ed_p))->hwNextED))
 655  inter =rev(6,((struct usb_ohci_ed *)bus_to_virt(*ed_p))->int_interval);
 656 *ed_p =virt_to_bus(ed);
 657 }
 658  ed->ed_prev = NULL;
 659 }
 660  ed->hwNextED =0;
 661  ohci->ed_isotail = ed;
 662 break;
 663 }
 664
 665
 666 return1;
 667 }
 668
 669 /* unlink an ed from one of the HC chains.
 670  * just the link to the ed is unlinked.
 671  * the link from the ed still points to another operational ed or 0
 672  * so the HC can eventually finish the processing of the unlinked ed
 673  * */
 674 static intohci_unlink_ed(struct ohci * ohci,struct usb_ohci_ed *ed) {
 675
 676 int int_branch;
 677 int i;
 678 int inter;
 679 int interval;
 680  __u32 * ed_p;
 681
 682
 683 switch(ED_TYPE(ed)) {
 684 case CTRL:
 685 if(ed->ed_prev == NULL) {
 686 writel(ed->hwNextED, &ohci->regs->ed_controlhead);
 687 }
 688 else{
 689  ed->ed_prev->hwNextED = ed->hwNextED;
 690 }
 691 if(ohci->ed_controltail == ed) {
 692  ohci->ed_controltail = ed->ed_prev;
 693 }
 694 else{
 695 ((struct usb_ohci_ed *)bus_to_virt(ed->hwNextED))->ed_prev = ed->ed_prev;
 696 }
 697 break;
 698
 699 case BULK:
 700 if(ed->ed_prev == NULL) {
 701 writel(ed->hwNextED, &ohci->regs->ed_bulkhead);
 702 }
 703 else{
 704  ed->ed_prev->hwNextED = ed->hwNextED;
 705 }
 706 if(ohci->ed_bulktail == ed) {
 707  ohci->ed_bulktail = ed->ed_prev;
 708 }
 709 else{
 710 ((struct usb_ohci_ed *)bus_to_virt(ed->hwNextED))->ed_prev = ed->ed_prev;
 711 }
 712 break;
 713
 714 case INT:
 715  int_branch = ed->int_branch;
 716  interval = ed->int_interval;
 717
 718 for( i=0; i <rev(6,interval); i += inter) {
 719 for(ed_p = &(ohci->hc_area->hcca.int_table[rev(5,i)+int_branch]), inter =1;
 720 (*ed_p !=0) && (*ed_p != ed->hwNextED);
 721  ed_p = &(((struct usb_ohci_ed *)bus_to_virt(*ed_p))->hwNextED),
 722  inter =rev(6, ((struct usb_ohci_ed *)bus_to_virt(*ed_p))->int_interval)) {
 723 if(((struct usb_ohci_ed *)bus_to_virt(*ed_p)) == ed) {
 724 *ed_p = ed->hwNextED;
 725 break;
 726 }
 727 }
 728 OHCI_DEBUG(printk("int_link i: %2x, inter: %2x, ed: %4x\n", i, inter, ed->hwINFO);)
 729 }
 730 for(i=int_branch; i<32; i+=interval) ohci->ohci_int_load[i] -= ed->int_load;
 731 break;
 732
 733 case ISO:
 734 if(ohci->ed_isotail == ed)
 735  ohci->ed_isotail = ed->ed_prev;
 736 if(ed->hwNextED !=0)
 737 ((struct usb_ohci_ed *)bus_to_virt(ed->hwNextED))->ed_prev = ed->ed_prev;
 738
 739 if(ed->ed_prev != NULL) {
 740  ed->ed_prev->hwNextED = ed->hwNextED;
 741 }
 742 else{
 743 for( i=0; i <32; i += inter) {
 744  inter =1;
 745 for(ed_p = &(ohci->hc_area->hcca.int_table[rev(5,i)]);
 746 *ed_p !=0;
 747  ed_p = &(((struct usb_ohci_ed *)bus_to_virt(*ed_p))->hwNextED)) {
 748  inter =rev(6,((struct usb_ohci_ed *)bus_to_virt(*ed_p))->int_interval);
 749 if(((struct usb_ohci_ed *)bus_to_virt(*ed_p)) == ed) {
 750 *ed_p = ed->hwNextED;
 751 break;
 752 }
 753 }
 754 }
 755 }
 756 break;
 757 }
 758 ED_setSTATE(ed, ED_UNLINK);
 759 return1;
 760 }
 761
 762 spinlock_t usb_ed_lock = SPIN_LOCK_UNLOCKED;
 763
 764 /* add/reinit an endpoint; this should be done once at the usb_set_configuration command,
 765  * but the USB stack is a little bit stateless so we do it at every transaction
 766  * if the state of the ed is ED_NEW then a dummy td is added and the state is changed to ED_UNLINK
 767  * in all other cases the state is left unchanged
 768  * the ed info fields are setted anyway even though they should not change
 769  * */
 770 struct usb_ohci_ed *usb_ohci_add_ep(struct usb_device * usb_dev,struct usb_hcd_ed * hcd_ed,int interval,int load) {
 771
 772 // struct ohci * ohci = usb_dev->bus->hcpriv;
 773 struct usb_ohci_td * td;
 774 struct usb_ohci_ed * ed, *ed1;
 775
 776 int ed_state, ed_state1;
 777
 778 spin_lock(&usb_ed_lock);
 779
 780  ed =ohci_find_ep(usb_dev, hcd_ed);
 781
 782
 783  ed1 = ((void*) ed) +0x40; ed_state1 =ED_STATE(ed1);
 784 OHCI_DEBUG(printk("++++ USB HC add 60 ed1 %x: %x :state: %x\n", ed1->hwINFO, (unsigned int) ed1, ed_state1); )
 785  ed_state =ED_STATE(ed);/* store state of ed */
 786 OHCI_DEBUG(printk("USB HC add ed %x: %x :state: %x\n", ed->hwINFO, (unsigned int) ed, ed_state); )
 787 if(ed_state == ED_NEW) {
 788 OHCI_ALLOC(td,sizeof(*td));/* dummy td; end of td list for ed */
 789  ed->hwTailP =virt_to_bus(td);
 790  ed->hwHeadP = ed->hwTailP;
 791  ed_state = ED_UNLINK;
 792 }
 793
 794  ed->hwINFO = hcd_ed->function
 795 | hcd_ed->endpoint <<7
 796 | (hcd_ed->type == ISO?0x8000:0)
 797 | (hcd_ed->type == CTRL?0:(hcd_ed->out ==1?0x800:0x1000))
 798 | hcd_ed->slow <<13
 799 | hcd_ed->maxpack <<16
 800 | hcd_ed->type <<27
 801 // | 1 << 14
 802 | ed_state <<29;
 803
 804 if(ED_TYPE(ed) == INT && ed_state == ED_UNLINK) {
 805  ed->int_period = interval;
 806  ed->int_load = load;
 807 }
 808
 809 spin_unlock(&usb_ed_lock);
 810 return ed;
 811 }
 812
 813
 814
 815 /*****
 816  * Request the removal of an endpoint
 817  *
 818  * put the ep on the rm_list and request a stop of the bulk or ctrl list
 819  * real removal is done at the next start of frame (SOF) hardware interrupt
 820  * the dummy td carries the essential information (handler, proc queue, ...)
 821  * if(send & TD_RM) then just the TD witch have (TD->type & DEL) set will be removed
 822  * otherwise all TDs including the dummy TD of the ED will be removed
 823  */
 824 intusb_ohci_rm_ep(struct usb_device * usb_dev,struct usb_ohci_ed *ed, f_handler handler, __OHCI_BAG lw0, __OHCI_BAG lw1,int send)
 825 {
 826 unsigned int flags;
 827
 828 struct ohci * ohci = usb_dev->bus->hcpriv;
 829 struct usb_ohci_td *td;
 830
 831 OHCI_DEBUG(printk("USB HC remove ed %x: %x :\n", ed->hwINFO, (unsigned int) ed); )
 832
 833 spin_lock_irqsave(&usb_ed_lock, flags);
 834  ed->hwINFO |= OHCI_ED_SKIP;
 835 writel( OHCI_INTR_SF, &ohci->regs->intrenable);/* enable sof interrupt */
 836
 837
 838 if(send & TD_RM) {/* delete selected TDs */
 839 ED_setSTATE(ed, ED_TD_DEL);
 840 }
 841 else{/* delete all TDS */
 842 if(ED_STATE(ed) == ED_OPER)ohci_unlink_ed(ohci, ed);
 843  td = (struct usb_ohci_td *)bus_to_virt(ed->hwTailP);
 844  td->lw0 = lw0;
 845  td->lw1 = lw1;
 846  td->ed = ed;
 847  td->hwINFO = TD_CC;
 848  td->handler = handler;
 849  td->type = send;
 850 ED_setSTATE(ed, ED_DEL);
 851 }
 852  ed->ed_prev = ohci->ed_rm_list;
 853  ohci->ed_rm_list = ed;
 854
 855 switch(ED_TYPE(ed)) {
 856 case CTRL:
 857 writel_mask(~(0x01<<4), &ohci->regs->control);/* stop CTRL list */
 858 break;
 859 case BULK:
 860 writel_mask(~(0x01<<5), &ohci->regs->control);/* stop BULK list */
 861 break;
 862 }
 863
 864 spin_unlock_irqrestore(&usb_ed_lock, flags);
 865
 866 return1;
 867 }
 868
 869
 870 /* remove all endpoints of a function (device)
 871  * just the last ed sends a reply
 872  * the last ed is ed0 as there always should be an ep0
 873  * */
 874 intusb_ohci_rm_function(struct usb_device * usb_dev, f_handler handler,__OHCI_BAG tw0, __OHCI_BAG tw1)
 875 {
 876 struct usb_ohci_ed *ed;
 877 int i;
 878 int cnt =0;
 879
 880
 881 for(i = NUM_EDS -1; i >=0; i--) {
 882  ed = &(usb_to_ohci(usb_dev)->ed[i]);
 883 if(ED_STATE(ed) != ED_NEW) {
 884 OHCI_DEBUG(printk("USB RM FUNCTION ed: %4x;\n", ed->hwINFO);)
 885 usb_ohci_rm_ep(usb_dev, ed, handler, tw0, tw1, i==0?SEND:0);
 886  cnt++;
 887 }
 888 }
 889 OHCI_DEBUG(printk("USB RM FUNCTION %d eds removed;\n", cnt);)
 890 return cnt;
 891 }
 892
 893
 894
 895 /******
 896  *** TD handling functions
 897  ************************************/
 898
 899
 900 #define FILL_TD(INFO, DATA, LEN, LW0, LW1, TYPE, HANDLER) \
 901  OHCI_ALLOC(td_pt, sizeof(*td_pt)); \
 902  td_ret = (struct usb_ohci_td *) bus_to_virt(usb_ed->hwTailP & 0xfffffff0); \
 903  td_pt1 = td_ret; \
 904  td_pt1->ed = ed; \
 905  td_pt1->buffer_start = (DATA); \
 906  td_pt1->type = (TYPE); \
 907  td_pt1->handler = (HANDLER); \
 908  td_pt1->lw0 = (LW0); \
 909  td_pt1->lw1 = (LW1); \
 910  td_pt1->hwINFO = (INFO); \
 911  td_pt1->hwCBP = (((DATA)==NULL)||((LEN)==0))?0:virt_to_bus(DATA); \
 912  td_pt1->hwBE = (((DATA)==NULL)||((LEN)==0))?0:virt_to_bus((DATA) + (LEN) - 1); \
 913  td_pt1->hwNextTD = virt_to_bus(td_pt); \
 914  td_pt->hwNextTD = 0; \
 915  usb_ed->hwTailP = td_pt1->hwNextTD
 916
 917 #define FILL_ISO_TD(INFO, DATA, LEN, LW0, LW1, TYPE, HANDLER) \
 918  OHCI_ALLOC(td_pt, sizeof(*td_pt)); \
 919  td_ret = (struct usb_ohci_td *) bus_to_virt(usb_ed->hwTailP & 0xfffffff0); \
 920  td_pt1 = td_ret; \
 921  td_pt1->ed = ed; \
 922  td_pt1->buffer_start = (DATA); \
 923  td_pt1->type = (TYPE); \
 924  td_pt1->handler = (HANDLER); \
 925  td_pt1->lw0 = (LW0); \
 926  td_pt1->lw1 = (LW1); \
 927  td_pt1->hwINFO = (INFO); \
 928  td_pt1->hwCBP = (((DATA)==NULL)||((LEN)==0))?0:(virt_to_bus(DATA) & 0xfffff000); \
 929  td_pt1->hwBE = (((DATA)==NULL)||((LEN)==0))?0:virt_to_bus((DATA) + (LEN) - 1); \
 930  td_pt1->hwNextTD = virt_to_bus(td_pt); \
 931  td_pt1->hwPSW[0] = (virt_to_bus(DATA) & 0xfff) | 0xe000; \
 932  td_pt->hwNextTD = 0; \
 933  usb_ed->hwTailP = td_pt1->hwNextTD
 934
 935
 936 spinlock_t usb_req_lock = SPIN_LOCK_UNLOCKED;
 937
 938 struct usb_ohci_td *ohci_trans_req(struct ohci * ohci,struct usb_ohci_ed * ed,int ctrl_len,
 939 void*ctrl,void* data,int data_len, __OHCI_BAG lw0, __OHCI_BAG lw1,unsigned int ed_type, f_handler handler) {
 940
 941
 942 unsigned int flags;
 943 volatilestruct usb_ohci_ed *usb_ed = ed;
 944 volatilestruct usb_ohci_td *td_pt;
 945 volatilestruct usb_ohci_td *td_pt1 = NULL;
 946
 947 struct usb_ohci_td *td_ret = NULL;
 948
 949 int cnt =0;
 950
 951
 952 if(usb_ed == NULL )return NULL;/* not known ep */
 953
 954
 955 spin_lock_irqsave(&usb_req_lock, flags);
 956
 957 switch(ed_type) {
 958 case BULK_IN:
 959 while(data_len >4096)
 960 {
 961 FILL_TD( TD_CC | TD_DP_IN | TD_T_TOGGLE, data,4096, NULL, NULL, BULK_IN | ADD_LEN|(cnt++?0:ST_ADDR), NULL);
 962  data +=4096; data_len -=4096;
 963 }
 964 FILL_TD( TD_CC | TD_R | TD_DP_IN | TD_T_TOGGLE, data, data_len, lw0, lw1, BULK_IN |ADD_LEN|SEND|(cnt++?0:ST_ADDR), handler);
 965 writel( OHCI_BLF, &ohci->regs->cmdstatus);/* start bulk list */
 966 break;
 967
 968 case BULK_OUT:
 969 while(data_len >4096)
 970 {
 971 FILL_TD( TD_CC | TD_DP_OUT | TD_T_TOGGLE, data,4096, NULL, NULL, BULK_OUT | ADD_LEN|(cnt++?0:ST_ADDR), NULL);
 972  data +=4096; data_len -=4096;
 973 }
 974 FILL_TD( TD_CC | TD_DP_OUT | TD_T_TOGGLE, data, data_len, lw0, lw1, BULK_OUT |ADD_LEN|SEND|(cnt++?0:ST_ADDR), handler);
 975 writel( OHCI_BLF, &ohci->regs->cmdstatus);/* start bulk list */
 976 break;
 977
 978 case INT_IN:
 979 FILL_TD( TD_CC | TD_R | TD_DP_IN | TD_T_TOGGLE, data, data_len, lw0, lw1, INT_IN | ST_ADDR|ADD_LEN|SEND, handler);
 980 break;
 981
 982 case INT_OUT:
 983 FILL_TD( TD_CC | TD_DP_OUT | TD_T_TOGGLE, data, data_len, lw0, lw1, INT_OUT | ST_ADDR|ADD_LEN|SEND, handler);
 984 break;
 985
 986 case CTRL_IN:
 987 FILL_TD( TD_CC | TD_DP_SETUP | TD_T_DATA0, ctrl, ctrl_len,0,0, CTRL_SETUP |ST_ADDR, NULL);
 988 if(data_len >0) {
 989 FILL_TD( TD_CC | TD_R | TD_DP_IN | TD_T_DATA1, data, data_len,0,0, CTRL_DATA_IN | ST_ADDR|ADD_LEN, NULL);
 990 }
 991 FILL_TD( TD_CC | TD_DP_OUT | TD_T_DATA1, NULL,0, lw0, lw1, CTRL_STATUS_OUT |SEND, handler);
 992 writel( OHCI_CLF, &ohci->regs->cmdstatus);/* start Control list */
 993 break;
 994
 995 case CTRL_OUT:
 996 FILL_TD( TD_CC | TD_DP_SETUP | TD_T_DATA0, ctrl, ctrl_len,0,0, CTRL_SETUP |ST_ADDR, NULL);
 997 if(data_len >0) {
 998 FILL_TD( TD_CC | TD_R | TD_DP_OUT | TD_T_DATA1, data, data_len,0,0, CTRL_DATA_OUT | ST_ADDR|ADD_LEN, NULL);
 999 }
1000 FILL_TD( TD_CC | TD_DP_IN | TD_T_DATA1, NULL,0, lw0, lw1, CTRL_STATUS_IN |SEND, handler);
1001 writel( OHCI_CLF, &ohci->regs->cmdstatus);/* start Control list */
1002 break;
1003
1004 case ISO_IN:
1005 FILL_ISO_TD( TD_CC|TD_ISO|(ctrl_len &0xffff), data, data_len, lw0, lw1, ISO_IN | ST_ADDR|ADD_LEN|SEND, handler);
1006 break;
1007
1008 case ISO_OUT:
1009 FILL_ISO_TD( TD_CC|TD_ISO|(ctrl_len &0xffff), data, data_len, lw0, lw1, ISO_OUT | ST_ADDR|ADD_LEN|SEND, handler);
1010 break;
1011 }
1012
1013 spin_unlock_irqrestore(&usb_req_lock, flags);
1014 return td_ret;
1015 }
1016
1017
1018 /******
1019  *** Done List handling functions
1020  ************************************/
1021 /* the HC halts an ED if an error occurs;
1022  * on error move all pending tds of a transaction (from ed) onto the done list
1023  * * */
1024 static struct usb_ohci_td *ohci_append_error_tds(struct usb_ohci_td * td_list,struct usb_ohci_td * td_rev) {
1025
1026 struct usb_ohci_td * tdl;
1027 struct usb_ohci_td * tdx;
1028 struct usb_ohci_td * tdt;
1029 int cc;
1030
1031  tdl = (struct usb_ohci_td *)bus_to_virt( td_list->ed->hwHeadP &0xfffffff0);
1032  tdt = (struct usb_ohci_td *)bus_to_virt( td_list->ed->hwTailP);
1033  cc =TD_CC_GET(td_list->hwINFO);
1034
1035 for( tdx = tdl; tdx != tdt; tdx = tdx->next_dl_td) {
1036 if(tdx->type & SEND)break;
1037  tdx->next_dl_td =bus_to_virt(tdx->hwNextTD &0xfffffff0);
1038 }
1039  tdx->next_dl_td = td_rev;
1040  td_list->ed->hwHeadP = (tdx->hwNextTD &0xfffffff0) | (td_list->ed->hwHeadP &0x2);
1041 TD_CC_SET(tdx->hwINFO, cc);
1042 return tdl;
1043 }
1044
1045 /* replies to the request have to be on a FIFO basis so
1046  * we reverse the reversed done-list */
1047
1048 static struct usb_ohci_td *ohci_reverse_done_list(struct ohci * ohci) {
1049
1050  __u32 td_list_hc;
1051 struct usb_ohci_td * td_rev = NULL;
1052 struct usb_ohci_td * td_list = NULL;
1053
1054  td_list_hc = ohci->hc_area->hcca.done_head &0xfffffff0;
1055  ohci->hc_area->hcca.done_head =0;
1056
1057
1058 while(td_list_hc) {
1059
1060  td_list = (struct usb_ohci_td *)bus_to_virt(td_list_hc);
1061 if(TD_CC_GET(td_list->hwINFO) && !(td_list->type & SEND))
1062  td_list->next_dl_td =ohci_append_error_tds(td_list, td_rev);
1063 else
1064  td_list->next_dl_td = td_rev;
1065
1066  td_rev = td_list;
1067  td_list_hc = td_list->hwNextTD &0xfffffff0;
1068
1069
1070 }
1071 return td_list;
1072 }
1073
1074 /* there are some pending requests to remove some of the eds
1075  * we either process every td including the dummy td of these eds
1076  * or just those marked with TD->type&DEL
1077  * and link them to a list
1078  * */
1079 static struct usb_ohci_td *usb_ohci_del_list(struct ohci * ohci) {
1080 struct usb_ohci_ed * ed;
1081 struct usb_ohci_td * td;
1082 struct usb_ohci_td * td_tmp = NULL;
1083 struct usb_ohci_td * td_list = NULL;
1084  __u32 * td_hw;
1085
1086 for(ed = ohci->ed_rm_list; ed != NULL; ed = ed->ed_prev) {
1087 OHCI_DEBUG(printk("USB HC ed_rm_list: %4x :\n", ed->hwINFO);)
1088
1089
1090 for( td_hw = &(ed->hwHeadP); (*td_hw &0xfffffff0) != ed->hwTailP; td_hw = &(td->hwNextTD)) {
1091  td = (struct usb_ohci_td *)bus_to_virt(*td_hw &0xfffffff0);
1092 if((ED_STATE(ed) == ED_DEL) || (td->type & DEL)) {
1093 *td_hw = td->hwNextTD;
1094 if(td_list == NULL)
1095  td_list = td;
1096 else
1097  td_tmp->next_dl_td = td;
1098  td_tmp = td;
1099 OHCI_DEBUG(printk("USB HC ed_rm_list: td: %4x\n", (unsigned int) td);)
1100  td->next_dl_td = NULL;
1101 }
1102 }
1103 if(ED_STATE(ed) == ED_DEL) {/* send dummy td */
1104  td = (struct usb_ohci_td *)bus_to_virt(*td_hw &0xfffffff0);
1105  td->ed = ed;
1106 if(td_list == NULL)
1107  td_list = td;
1108 else
1109  td_tmp->next_dl_td = td;
1110  td_tmp = td;
1111  td->type |= DEL_ED;
1112 OHCI_DEBUG(printk("USB HC ed_rm_list: dummy (ED_DEL) td: %4x\n", (unsigned int) td);)
1113 ED_setSTATE(td->ed, ED_DEL| ED_NEW);
1114  td->next_dl_td = NULL;
1115 }
1116 if(ED_TYPE(ed) == CTRL)writel(0, &ohci->regs->ed_controlcurrent);/* reset CTRL list */
1117 if(ED_TYPE(ed) == BULK)writel(0, &ohci->regs->ed_bulkcurrent);/* reset BULK list */
1118
1119 }
1120
1121 writel_set((0x03<<4), &ohci->regs->control);/* start CTRL u. BULK list */
1122
1123  ohci->ed_rm_list = NULL;
1124
1125
1126 return td_list;
1127 }
1128
1129
1130 /* all tds ever alive go through this loop
1131  * requests are replied here
1132  * the handler is the
1133  * interface handler (blocking/non blocking) the real reply-handler
1134  * is called in the non blocking interface routine
1135  * */
1136 static intusb_ohci_done_list(struct ohci * ohci,struct usb_ohci_td * td_list) {
1137
1138 struct usb_ohci_td * td_list_next = NULL;
1139
1140 int cc;
1141 int i;
1142
1143 while(td_list) {
1144  td_list_next = td_list->next_dl_td;
1145
1146 if(td_list->type & ST_ADDR) {/* remember start address of data buffer */
1147  td_list->ed->buffer_start = td_list->buffer_start;
1148  td_list->ed->len =0;
1149 }
1150
1151 if(td_list->type & ADD_LEN) {/* accumulate length of multi td transfers */
1152 if(td_list->hwINFO & TD_ISO) {
1153 for(i=0; i <= ((td_list->hwINFO >>24) &0x7); i++)
1154 if((td_list->hwPSW[i] >>12) <0xE) td_list->ed->len += (td_list->hwPSW[i] &0x3ff);
1155 }
1156 else{
1157 if(td_list->hwBE !=0) {
1158 if(td_list->hwCBP ==0)
1159  td_list->ed->len += (bus_to_virt(td_list->hwBE) - td_list->buffer_start +1);
1160 else
1161  td_list->ed->len += (bus_to_virt(td_list->hwCBP) - td_list->buffer_start);
1162 }
1163 }
1164 }
1165 /* error code of transfer */
1166  cc = (ED_STATE(td_list->ed) == ED_DEL || (td_list->type & DEL))? USB_ST_REMOVED : (USB_ST_CRC*TD_CC_GET(td_list->hwINFO));
1167
1168 if(td_list->type & DEL_ED)ED_setSTATE(td_list->ed, ED_NEW);/* remove ed */
1169
1170 if((td_list->type & SEND) && (ED_STATE(td_list->ed) != ED_STOP) && (td_list->handler)) {/* send the reply */
1171  td_list->handler((void*) ohci,
1172  td_list->ed,
1173  td_list->ed->buffer_start,
1174  td_list->ed->len,
1175  cc,
1176  td_list->lw0,
1177  td_list->lw1);
1178 OHCI_DEBUG(if(cc != TD_CC_NOERROR)printk("******* USB BUS error %x @ep %x\n",TD_CC_GET(td_list->hwINFO), td_list->ed->hwINFO);)
1179
1180 }
1181 if(ED_STATE(td_list->ed) == ED_TD_DEL) td_list->ed->hwINFO &= ~OHCI_ED_SKIP;
1182
1183 if(((td_list->ed->hwHeadP &0xfffffff0) == td_list->ed->hwTailP) && (ED_STATE(td_list->ed) > ED_UNLINK))
1184 ohci_unlink_ed(ohci, td_list->ed);/* unlink eds if they are not busy */
1185
1186 OHCI_FREE(td_list);
1187  td_list = td_list_next;
1188 }
1189 return0;
1190 }
1191
1192
1193
1194 /******
1195  *** HC functions
1196  ************************************/
1197
1198
1199 /* reset the HC not the BUS */
1200 voidreset_hc(struct ohci *ohci) {
1201
1202 int timeout =30;
1203 int smm_timeout =50;/* 0,5 sec */
1204
1205 if(readl(&ohci->regs->control) &0x100) {/* SMM owns the HC */
1206 writel(0x08, &ohci->regs->cmdstatus);/* request ownership */
1207 printk("USB HC TakeOver from SMM\n");
1208 while(readl(&ohci->regs->control) &0x100) {
1209 wait_ms(10);
1210 if(--smm_timeout ==0) {
1211 printk("USB HC TakeOver failed!\n");
1212 break;
1213 }
1214 }
1215 }
1216
1217 writel((1<<31), &ohci->regs->intrdisable);/* Disable HC interrupts */
1218 OHCI_DEBUG(printk("USB HC reset_hc: %x ;\n",readl(&ohci->regs->control));)
1219
1220 writel(1, &ohci->regs->cmdstatus);/* HC Reset */
1221 while((readl(&ohci->regs->cmdstatus) &0x01) !=0) {/* 10us Reset */
1222 if(--timeout ==0) {
1223 printk("USB HC reset timed out!\n");
1224 return;
1225 }
1226 udelay(1);
1227 }
1228 }
1229 static struct ohci *__ohci;
1230
1231 /*
1232  * Start an OHCI controller, set the BUS operational
1233  * set and enable interrupts
1234  * connect the virtual root hub
1235  * * */
1236
1237 intstart_hc(struct ohci *ohci)
1238 {
1239 unsigned int mask;
1240 int fminterval;
1241
1242 /*
1243  * Tell the controller where the control and bulk lists are
1244  * The lists are empty now.
1245  */
1246 writel(0, &ohci->regs->ed_controlhead);
1247 writel(0, &ohci->regs->ed_bulkhead);
1248
1249 writel(virt_to_bus(&ohci->hc_area->hcca), &ohci->regs->hcca);/* a reset clears this */
1250
1251 writel((0xBF), &ohci->regs->control);/* USB Operational */
1252
1253  fminterval =0x2edf;
1254 writel(((fminterval)*9)/10, &ohci->regs->periodicstart);
1255  fminterval |= ((((fminterval -210) *6)/7)<<16);
1256 writel(fminterval, &ohci->regs->fminterval);
1257 writel(0x628, &ohci->regs->lsthresh);
1258 OHCI_DEBUG(printk("USB HC fminterval: %x\n",readl( &(ohci->regs->fminterval) )); )
1259 OHCI_DEBUG(printk("USB HC periodicstart: %x\n",readl( &(ohci->regs->periodicstart) )); )
1260 OHCI_DEBUG(printk("USB HC lsthresh: %x\n",readl( &(ohci->regs->lsthresh) )); )
1261 OHCI_DEBUG(printk("USB HC control: %x\n",readl(&ohci->regs->control)); )
1262 OHCI_DEBUG(printk("USB HC roothubstata: %x\n",readl( &(ohci->regs->roothub.a) )); )
1263 OHCI_DEBUG(printk("USB HC roothubstatb: %x\n",readl( &(ohci->regs->roothub.b) )); )
1264 OHCI_DEBUG(printk("USB HC roothubstatu: %x\n",readl( &(ohci->regs->roothub.status) )); )
1265 OHCI_DEBUG(printk("USB HC roothubstat1: %x\n",readl( &(ohci->regs->roothub.portstatus[0]) )); )
1266 OHCI_DEBUG(printk("USB HC roothubstat2: %x\n",readl( &(ohci->regs->roothub.portstatus[1]) )); )
1267 /* Choose the interrupts we care about now, others later on demand */
1268  mask = OHCI_INTR_MIE | OHCI_INTR_WDH | OHCI_INTR_SO;
1269
1270 writel(mask, &ohci->regs->intrenable);
1271 writel(mask, &ohci->regs->intrstatus);
1272
1273 #ifdef VROOTHUB
1274 {
1275 /* connect the virtual root hub */
1276 struct usb_device * usb_dev;
1277 struct ohci_device *dev;
1278
1279
1280  usb_dev =usb_alloc_dev(NULL, ohci->bus);
1281 if(!usb_dev)return-1;
1282
1283  dev =usb_to_ohci(usb_dev);
1284 // usb_dev->bus = ohci->bus;
1285  ohci->bus->root_hub = usb_dev;
1286  dev->ohci = ohci;
1287 usb_connect(usb_dev);
1288 if(usb_new_device(usb_dev) !=0) {
1289 usb_free_dev(usb_dev);
1290 return-1;
1291 }
1292
1293 }
1294 #endif
1295 return0;
1296 }
1297
1298 /* an interrupt happens */
1299 static voidohci_interrupt(int irq,void*__ohci,struct pt_regs *r)
1300 {
1301 struct ohci *ohci = __ohci;
1302 struct ohci_regs *regs = ohci->regs;
1303 int ints;
1304
1305 if((ohci->hc_area->hcca.done_head !=0) && !(ohci->hc_area->hcca.done_head &0x01)) {
1306  ints = OHCI_INTR_WDH;
1307 }
1308 else{
1309 if((ints = (readl(&regs->intrstatus) &readl(&regs->intrenable))) ==0)
1310 return;
1311 }
1312
1313 OHCI_DEBUG(printk("USB HC interrupt: %x (%x)\n", ints,readl(&regs->intrstatus));)
1314
1315
1316 if(ints & OHCI_INTR_WDH) {
1317 writel(OHCI_INTR_WDH, &regs->intrdisable);
1318 usb_ohci_done_list(ohci,ohci_reverse_done_list(ohci));
1319 writel(OHCI_INTR_WDH, &regs->intrenable);
1320 }
1321
1322 if(ints & OHCI_INTR_SO) {
1323 printk("**** USB Schedule overrun ");
1324 writel(OHCI_INTR_SO, &regs->intrenable);
1325 }
1326
1327 if(ints & OHCI_INTR_SF) {
1328 writel(OHCI_INTR_SF, &regs->intrdisable);
1329 if(ohci->ed_rm_list != NULL) {
1330 usb_ohci_done_list(ohci,usb_ohci_del_list(ohci));
1331 }
1332 }
1333 writel(ints, &regs->intrstatus);
1334 writel(OHCI_INTR_MIE, &regs->intrenable);
1335 }
1336
1337 /* allocate OHCI */
1338
1339 static struct ohci *alloc_ohci(void* mem_base)
1340 {
1341 int i;
1342 struct ohci *ohci;
1343 struct ohci_hc_area *hc_area;
1344 struct usb_bus *bus;
1345
1346  hc_area = (struct ohci_hc_area *)__get_free_pages(GFP_KERNEL,1);
1347 if(!hc_area)
1348 return NULL;
1349
1350 memset(hc_area,0,sizeof(*hc_area));
1351  ohci = &hc_area->ohci;
1352  ohci->irq = -1;
1353  ohci->regs = mem_base;
1354  ohci->hc_area = hc_area;
1355  __ohci = ohci;
1356 /*
1357  * for load ballancing of the interrupt branches
1358  */
1359 for(i =0; i < NUM_INTS; i++) ohci->ohci_int_load[i] =0;
1360 for(i =0; i < NUM_INTS; i++) hc_area->hcca.int_table[i] =0;
1361
1362 /*
1363  * Store the end of control and bulk list eds. So, we know where we can add
1364  * elements to these lists.
1365  */
1366  ohci->ed_isotail = NULL;
1367  ohci->ed_controltail = NULL;
1368  ohci->ed_bulktail = NULL;
1369
1370  bus =usb_alloc_bus(&sohci_device_operations);
1371 if(!bus) {
1372 free_pages((unsigned int) ohci->hc_area,1);
1373 return NULL;
1374 }
1375
1376  ohci->bus = bus;
1377  bus->hcpriv = (void*) ohci;
1378
1379 return ohci;
1380 }
1381
1382
1383 /*
1384  * De-allocate all resources..
1385  * */
1386 static voidrelease_ohci(struct ohci *ohci)
1387 {
1388
1389 OHCI_DEBUG(printk("USB HC release ohci\n"););
1390 /* stop hc */
1391
1392
1393
1394 /* disconnect all devices */
1395 if(ohci->bus->root_hub)usb_disconnect(&ohci->bus->root_hub);
1396
1397 reset_hc(__ohci);
1398 writel(OHCI_USB_RESET, &ohci->regs->control);
1399 wait_ms(10);
1400
1401 if(ohci->irq >=0) {
1402 free_irq(ohci->irq, ohci);
1403  ohci->irq = -1;
1404 }
1405
1406 usb_deregister_bus(ohci->bus);
1407 usb_free_bus(ohci->bus);
1408
1409 /* unmap the IO address space */
1410 iounmap(ohci->regs);
1411
1412 free_pages((unsigned int) ohci->hc_area,1);
1413 }
1414
1415
1416 /*
1417  * Increment the module usage count, start the control thread and
1418  * return success.
1419  * */
1420 static intfound_ohci(int irq,void* mem_base)
1421 {
1422 struct ohci *ohci;
1423 OHCI_DEBUG(printk("USB HC found ohci: irq= %d membase= %x\n", irq, (int)mem_base);)
1424
1425  ohci =alloc_ohci(mem_base);
1426 if(!ohci) {
1427 return-ENOMEM;
1428 }
1429
1430 reset_hc(ohci);
1431 writel(OHCI_USB_RESET, &ohci->regs->control);
1432 wait_ms(10);
1433 usb_register_bus(ohci->bus);
1434
1435 if(request_irq(irq, ohci_interrupt, SA_SHIRQ,"ohci-usb", ohci) ==0) {
1436  ohci->irq = irq;
1437 start_hc(ohci);
1438 return0;
1439 }
1440 release_ohci(ohci);
1441 return-EBUSY;
1442 }
1443
1444 static intstart_ohci(struct pci_dev *dev)
1445 {
1446 unsigned int mem_base = dev->resource[0].start;
1447
1448  mem_base = (unsigned int)ioremap_nocache(mem_base,4096);
1449
1450 if(!mem_base) {
1451 printk("Error mapping OHCI memory\n");
1452 return-EFAULT;
1453 }
1454 returnfound_ohci(dev->irq, (void*) mem_base);
1455 }
1456
1457
1458 #ifdef CONFIG_APM
1459 static inthandle_apm_event(apm_event_t event)
1460 {
1461 static int down =0;
1462
1463 switch(event) {
1464 case APM_SYS_SUSPEND:
1465 case APM_USER_SUSPEND:
1466 if(down) {
1467 printk(KERN_DEBUG "ohci: received extra suspend event\n");
1468 break;
1469 }
1470  down =1;
1471 break;
1472 case APM_NORMAL_RESUME:
1473 case APM_CRITICAL_RESUME:
1474 if(!down) {
1475 printk(KERN_DEBUG "ohci: received bogus resume event\n");
1476 break;
1477 }
1478  down =0;
1479 // start_hc(ohci);
1480 break;
1481 }
1482 return0;
1483 }
1484 #endif
1485
1486 #define PCI_CLASS_SERIAL_USB_OHCI 0x0C0310
1487
1488 intohci_hcd_init(void)
1489 {
1490 struct pci_dev *dev = NULL;
1491
1492 while((dev =pci_find_class(PCI_CLASS_SERIAL_USB_OHCI, dev))) {
1493 if(start_ohci(dev) <0)return-ENODEV;
1494 }
1495
1496 #ifdef CONFIG_APM
1497 apm_register_callback(&handle_apm_event);
1498 #endif
1499
1500 return0;
1501 }
1502
1503 #ifdef MODULE
1504 intinit_module(void)
1505 {
1506 returnohci_hcd_init();
1507 }
1508
1509 voidcleanup_module(void)
1510 {
1511 # ifdef CONFIG_APM
1512 apm_unregister_callback(&handle_apm_event);
1513 # endif
1514 release_ohci(__ohci);
1515 }
1516 #endif//MODULE
1517