Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 1616 → Rev 1615

/drivers/usb/uhci/hcd.inc
216,13 → 216,6
hc->frame_dma = GetPgAddr(hc->frame_base);
hc->frame_number = 0;
 
hc->td_pool = dma_pool_create("uhci_td", NULL,
sizeof(td_t), 16, 0);
if (!hc->td_pool)
{
dbgprintf("unable to create td dma_pool\n");
goto err_create_td_pool;
}
 
for (i = 0; i < UHCI_NUM_SKELQH; i++)
{
343,12 → 336,6
};
};
return true;
 
err_create_td_pool:
 
KernelFree(hc->frame_base);
 
return false;
};
 
u16_t __attribute__((aligned(16)))
409,10 → 396,9
{
td_t *td, *td_prev;
addr_t data_dma;
hc_t *hc = dev->host;
 
size_t packet_size = enp->size;
size_t size = req_size;
addr_t td_dma;
 
request_t *rq = (request_t*)kmalloc(sizeof(request_t),0);
 
434,9 → 420,7
packet_size = size;
};
 
td = dma_pool_alloc(hc->td_pool, 0, &td_dma);
td->dma = td_dma;
 
td = alloc_td();
td->link = 1;
 
if(rq->td_head == NULL)
481,10 → 465,6
td_t *td0, *td, *td_prev;
qh_t *qh;
addr_t data_dma = 0;
hc_t *hc = dev->host;
 
addr_t td_dma = 0;
 
bool retval;
 
 
496,11 → 476,8
rq->size = req_size;
rq->dev = dev;
 
td0 = dma_pool_alloc(hc->td_pool, 0, &td_dma);
td0->dma = td_dma;
td0 = alloc_td();
 
dbgprintf("alloc td0 %x dma %x\n", td0, td_dma);
 
td0->status = 0x00800000 | dev->speed;
td0->token = TOKEN( 8, DATA0, 0, dev->addr, 0x2D);
td0->buffer = DMA(req);
518,11 → 495,7
packet_size = size;
};
 
td = dma_pool_alloc(hc->td_pool, 0, &td_dma);
td->dma = td_dma;
 
dbgprintf("alloc td %x dma %x\n", td, td->dma);
 
td = alloc_td();
td_prev->link = td->dma | 4;
td->status = TD_CTRL_ACTIVE | dev->speed;
td->token = TOKEN(packet_size, toggle, 0,dev->addr, pid);
536,11 → 509,7
toggle ^= DATA1;
}
 
td = dma_pool_alloc(hc->td_pool, 0, &td_dma);
td->dma = td_dma;
 
dbgprintf("alloc td %x dma %x\n", td, td->dma);
 
td = alloc_td();
td_prev->link = td->dma | 4;
 
pid = (pid == DIN) ? DOUT : DIN;
604,7 → 573,7
do
{
td_prev = td->bk;
dma_pool_free(hc->td_pool, td, td->dma);
free_td(td);
td = td_prev;
}while( td != NULL);
 
/drivers/usb/uhci/usb.c
1,17 → 1,24
 
 
#include <ddk.h>
#include <kernel.h>
#include <mutex.h>
#include <pci.h>
#include <linux/dmapool.h>
 
//#include <stdio.h>
//#include <malloc.h>
//#include <memory.h>
 
 
#include <syscall.h>
#include "usb.h"
 
 
int __stdcall srv_usb(ioctl_t *io);
 
bool init_hc(hc_t *hc);
 
static slab_t qh_slab;
static slab_t td_slab;
 
LIST_HEAD( hc_list );
LIST_HEAD( newdev_list );
56,17 → 63,31
p->r1 = 0;
};
 
td_slab.available = 128;
td_slab.start = KernelAlloc(4096);
td_slab.nextavail = (addr_t)td_slab.start;
td_slab.dma = GetPgAddr(td_slab.start);
 
td_t *td;
for (i = 0, td = (td_t*)td_slab.start, dma = td_slab.dma;
i < 128; i++, td++, dma+= sizeof(td_t))
{
td->link = (addr_t)(td+1);
td->status = 0;
td->token = 0;
td->buffer = 0;
td->dma = dma;
};
 
 
hc = (hc_t*)hc_list.next;
 
while( &hc->list != &hc_list)
{
hc_t *tmp = hc;
init_hc(hc);
hc = (hc_t*)hc->list.next;
}
 
if( !init_hc(tmp))
list_del(&tmp->list);
};
 
dbgprintf("\n");
 
dev = (udev_t*)newdev_list.next;
163,7 → 184,27
qh_slab.available++;
};
 
static td_t* alloc_td()
{
if( td_slab.available )
{
td_t *td;
 
td_slab.available--;
td = (td_t*)td_slab.nextavail;
td_slab.nextavail = td->link;
return td;
}
return NULL;
};
 
static void free_td(td_t *td)
{
td->link = td_slab.nextavail;
td_slab.nextavail = (addr_t)td;
td_slab.available++;
};
 
#include "pci.inc"
#include "detect.inc"
#include "hcd.inc"
/drivers/usb/uhci/usb.h
51,8 → 51,6
 
addr_t iobase;
 
struct dma_pool *td_pool;
 
u32_t *frame_base;
count_t frame_number;
addr_t frame_dma;
/drivers/usb/uhci/makefile
26,7 → 26,7
 
USB_OBJ:= usb.obj
 
LIBS:= -lddk -lcore
LIBS:= -ldrv -lcore
 
USB = usb.dll