Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 1615 → Rev 1616

/drivers/usb/uhci/hcd.inc
216,6 → 216,13
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++)
{
336,6 → 343,12
};
};
return true;
 
err_create_td_pool:
 
KernelFree(hc->frame_base);
 
return false;
};
 
u16_t __attribute__((aligned(16)))
396,9 → 409,10
{
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);
 
420,7 → 434,9
packet_size = size;
};
 
td = alloc_td();
td = dma_pool_alloc(hc->td_pool, 0, &td_dma);
td->dma = td_dma;
 
td->link = 1;
 
if(rq->td_head == NULL)
465,6 → 481,10
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;
 
 
476,8 → 496,11
rq->size = req_size;
rq->dev = dev;
 
td0 = alloc_td();
td0 = dma_pool_alloc(hc->td_pool, 0, &td_dma);
td0->dma = td_dma;
 
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);
495,7 → 518,11
packet_size = size;
};
 
td = alloc_td();
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_prev->link = td->dma | 4;
td->status = TD_CTRL_ACTIVE | dev->speed;
td->token = TOKEN(packet_size, toggle, 0,dev->addr, pid);
509,7 → 536,11
toggle ^= DATA1;
}
 
td = alloc_td();
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_prev->link = td->dma | 4;
 
pid = (pid == DIN) ? DOUT : DIN;
573,7 → 604,7
do
{
td_prev = td->bk;
free_td(td);
dma_pool_free(hc->td_pool, td, td->dma);
td = td_prev;
}while( td != NULL);
 
/drivers/usb/uhci/makefile
26,7 → 26,7
 
USB_OBJ:= usb.obj
 
LIBS:= -ldrv -lcore
LIBS:= -lddk -lcore
 
USB = usb.dll
 
/drivers/usb/uhci/usb.c
1,24 → 1,17
 
 
#include <kernel.h>
#include <ddk.h>
#include <mutex.h>
#include <pci.h>
 
//#include <stdio.h>
//#include <malloc.h>
//#include <memory.h>
 
 
#include <linux/dmapool.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 );
63,31 → 56,17
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)
{
init_hc(hc);
hc_t *tmp = hc;
hc = (hc_t*)hc->list.next;
}
 
if( !init_hc(tmp))
list_del(&tmp->list);
};
 
dbgprintf("\n");
 
dev = (udev_t*)newdev_list.next;
184,27 → 163,7
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,6 → 51,8
 
addr_t iobase;
 
struct dma_pool *td_pool;
 
u32_t *frame_base;
count_t frame_number;
addr_t frame_dma;