i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleaning whitespaces/tabs and styling

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26803 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Oliver Ruiz Dorantes
2008-08-04 20:03:23 +00:00
parent 20a5113818
commit 859039e124
3 changed files with 296 additions and 327 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/kernel/drivers/bluetooth/h2/h2generic/h2generic.c
+28 -37
View File
@@ -306,26 +306,22 @@ device_added(const usb_device* dev, void** cookie)
new_bt_dev->intr_in_ep = ep; new_bt_dev->intr_in_ep = ep;
new_bt_dev->max_packet_size_intr_in = ep->descr->max_packet_size; new_bt_dev->max_packet_size_intr_in = ep->descr->max_packet_size;
flowf("INT in\n"); flowf("INT in\n");
} else } else {
{
;
flowf("INT out\n"); flowf("INT out\n");
} }
break; break;
case USB_ENDPOINT_ATTR_BULK: case USB_ENDPOINT_ATTR_BULK:
if (ep->descr->endpoint_address & USB_ENDPOINT_ADDR_DIR_IN) if (ep->descr->endpoint_address & USB_ENDPOINT_ADDR_DIR_IN) {
{
new_bt_dev->bulk_in_ep = ep; new_bt_dev->bulk_in_ep = ep;
new_bt_dev->max_packet_size_bulk_in = ep->descr->max_packet_size;; new_bt_dev->max_packet_size_bulk_in = ep->descr->max_packet_size;;
flowf("BULK int\n"); flowf("BULK int\n");
} else } else {
{
new_bt_dev->bulk_out_ep = ep; new_bt_dev->bulk_out_ep = ep;
new_bt_dev->max_packet_size_bulk_out = ep->descr->max_packet_size;; new_bt_dev->max_packet_size_bulk_out = ep->descr->max_packet_size;;
flowf("BULK out\n"); flowf("BULK out\n");
} }
break; break;
} }
} }
@@ -442,41 +438,39 @@ device_open(const char *name, uint32 flags, void **cookie)
acquire_sem(bdev->lock); acquire_sem(bdev->lock);
// TX structures // TX structures
for (i = 0; i < BT_DRIVER_TXCOVERAGE; i++) { for (i = 0; i < BT_DRIVER_TXCOVERAGE; i++) {
list_init(&bdev->nbuffersTx[i]); list_init(&bdev->nbuffersTx[i]);
bdev->nbuffersPendingTx[i] = 0; bdev->nbuffersPendingTx[i] = 0;
} }
// RX structures // RX structures
bdev->eventRx = NULL; bdev->eventRx = NULL;
for (i = 0; i < BT_DRIVER_RXCOVERAGE; i++) { for (i = 0; i < BT_DRIVER_RXCOVERAGE; i++) {
bdev->nbufferRx[i] = NULL; bdev->nbufferRx[i] = NULL;
} }
// dumping the USB frames // dumping the USB frames
init_room(&bdev->eventRoom); init_room(&bdev->eventRoom);
init_room(&bdev->aclRoom); init_room(&bdev->aclRoom);
//init_room(new_bt_dev->scoRoom); //init_room(new_bt_dev->scoRoom);
list_init(&bdev->snetBufferRecycleTrash); list_init(&bdev->snetBufferRecycleTrash);
// Allocate set and register the HCI device // Allocate set and register the HCI device
if (btDevices != NULL) { if (btDevices != NULL) {
struct net_device* ndev; struct net_device* ndev;
// TODO: Fill the transport descriptor // TODO: Fill the transport descriptor
err = btDevices->init_device(bdev->name, &ndev); err = btDevices->init_device(bdev->name, &ndev);
if ( err == B_OK ) { if ( err == B_OK ) {
hdev = ndev->index; hdev = ndev->index;
bdev->ndev = ndev; bdev->ndev = ndev;
} else } else
hdev = bdev->num; /* XXX: Lets try to go on*/ hdev = bdev->num; /* XXX: Lets try to go on*/
} } else {
else {
hdev = bdev->num; /* XXX: Lets try to go on*/ hdev = bdev->num; /* XXX: Lets try to go on*/
} }
bdev->hdev = hdev; bdev->hdev = hdev;
*cookie = bdev; *cookie = bdev;
release_sem(bdev->lock); release_sem(bdev->lock);
@@ -553,8 +547,7 @@ device_free (void *cookie)
/* GotoLowPower */ /* GotoLowPower */
// interesting ..... // interesting .....
} } else {
else {
/* The last client has closed, and the device is no longer /* The last client has closed, and the device is no longer
connected, so remove it from the list. */ connected, so remove it from the list. */
} }
@@ -604,12 +597,12 @@ device_control(void *cookie, uint32 msg, void *params, size_t size)
(*(size_t**)&params)++; (*(size_t**)&params)++;
#endif #endif
// TODO: Reuse from some TXcompleted queue // TODO: Reuse from some TXcompleted queue
snbuf = snb_create(size); snbuf = snb_create(size);
snb_put(snbuf, params, size); snb_put(snbuf, params, size);
err = submit_tx_command(bdev, snbuf); err = submit_tx_command(bdev, snbuf);
debugf("device launched %ld\n", err); debugf("device launched %ld\n", err);
break; break;
case BT_UP: case BT_UP:
@@ -641,7 +634,7 @@ device_control(void *cookie, uint32 msg, void *params, size_t size)
flowf("device launched\n"); flowf("device launched\n");
break; break;
case GET_STATICS: case GET_STATS:
memcpy(params, &bdev->stat, sizeof(bt_hci_statistics)); memcpy(params, &bdev->stat, sizeof(bt_hci_statistics));
err = B_OK; err = B_OK;
break; break;
@@ -668,7 +661,7 @@ static status_t
device_read(void *cookie, off_t pos, void *buf, size_t *count) device_read(void *cookie, off_t pos, void *buf, size_t *count)
{ {
debugf("Reading... count = %ld\n", *count); debugf("Reading... count = %ld\n", *count);
*count = 0; *count = 0;
return B_OK; return B_OK;
} }
@@ -810,10 +803,8 @@ publish_devices(void)
} }
acquire_sem(dev_table_sem); acquire_sem(dev_table_sem);
for (j = 0; j < MAX_BT_GENERIC_USB_DEVICES; j++) for (j = 0; j < MAX_BT_GENERIC_USB_DEVICES; j++) {
{ if (bt_usb_devices[j] != NULL && bt_usb_devices[j]->connected) {
if (bt_usb_devices[j] != NULL && bt_usb_devices[j]->connected)
{
str = strdup(bt_usb_devices[j]->name); str = strdup(bt_usb_devices[j]->name);
if (str) { if (str) {
publish_names[i++] = str; publish_names[i++] = str;
@@ -842,16 +833,16 @@ publish_devices(void)
static device_hooks hooks = { static device_hooks hooks = {
device_open, device_open,
device_close, device_close,
device_free, device_free,
device_control, device_control,
device_read, device_read,
device_write, device_write,
NULL, NULL,
NULL, NULL,
NULL, NULL,
NULL NULL
}; };
src/add-ons/kernel/drivers/bluetooth/h2/h2generic/h2transactions.c
+215 -234
View File
@@ -39,100 +39,98 @@ void event_complete(void* cookie, status_t status, void* data, size_t actual_len
static status_t static status_t
assembly_rx(bt_usb_dev* bdev, bt_packet_t type, void *data, int count) assembly_rx(bt_usb_dev* bdev, bt_packet_t type, void *data, int count)
{ {
net_buffer* nbuf = NULL; net_buffer* nbuf = NULL;
snet_buffer* snbuf = NULL; snet_buffer* snbuf = NULL;
size_t currentPacketLen = 0; size_t currentPacketLen = 0;
size_t expectedPacketLen = 0; size_t expectedPacketLen = 0;
bdev->stat.bytesRX += count; bdev->stat.bytesRX += count;
if (type == BT_EVENT) if (type == BT_EVENT)
snbuf = bdev->eventRx; snbuf = bdev->eventRx;
else else
nbuf = bdev->nbufferRx[type]; nbuf = bdev->nbufferRx[type];
while (count) { while (count) {
debugf("count %d nb=%p sb=%p type=%d\n",count, nbuf, snbuf, type); debugf("count %d nb=%p sb=%p type=%d\n",count, nbuf, snbuf, type);
if ( (type != BT_EVENT && nbuf == NULL) || if ( (type != BT_EVENT && nbuf == NULL) ||
(type == BT_EVENT && (snbuf == NULL || snb_completed(snbuf))) ) { (type == BT_EVENT && (snbuf == NULL || snb_completed(snbuf))) ) {
/* new buffer incoming */ /* new buffer incoming */
switch (type) { switch (type) {
case BT_EVENT: case BT_EVENT:
if (count >= HCI_EVENT_HDR_SIZE) { if (count >= HCI_EVENT_HDR_SIZE) {
struct hci_event_header* headerPkt = data; struct hci_event_header* headerPkt = data;
expectedPacketLen = HCI_EVENT_HDR_SIZE + headerPkt->elen; expectedPacketLen = HCI_EVENT_HDR_SIZE + headerPkt->elen;
snbuf = bdev->eventRx = snb_fetch(&bdev->snetBufferRecycleTrash, expectedPacketLen); snbuf = bdev->eventRx = snb_fetch(&bdev->snetBufferRecycleTrash, expectedPacketLen);
} else { } else {
flowf("EVENT frame corrupted\n"); flowf("EVENT frame corrupted\n");
return -EILSEQ; return -EILSEQ;
} }
break; break;
case BT_ACL: case BT_ACL:
if (count >= HCI_ACL_HDR_SIZE) { if (count >= HCI_ACL_HDR_SIZE) {
int16 index; int16 index;
struct hci_acl_header* headerPkt = data; struct hci_acl_header* headerPkt = data;
expectedPacketLen = HCI_ACL_HDR_SIZE + B_LENDIAN_TO_HOST_INT16(headerPkt->alen); expectedPacketLen = HCI_ACL_HDR_SIZE + B_LENDIAN_TO_HOST_INT16(headerPkt->alen);
/* Create the buffer */ /* Create the buffer */
bdev->nbufferRx[type] = nbuf = nb->create(expectedPacketLen); bdev->nbufferRx[type] = nbuf = nb->create(expectedPacketLen);
// TODO: this allocation can fail!! // TODO: this allocation can fail!!
nbuf->protocol = type; nbuf->protocol = type;
debugf("new ACL frame %p\n", nbuf); debugf("new ACL frame %p\n", nbuf);
debugf("### Incoming ACL: len = %d\n", count); debugf("### Incoming ACL: len = %d\n", count);
for (index = 0 ; index < count; index++ ) { for (index = 0 ; index < count; index++ ) {
dprintf("%x:",((uint8*)data)[index]); dprintf("%x:",((uint8*)data)[index]);
} }
flowf("### \n"); flowf("### \n");
} else {
flowf("ACL frame corrupted\n");
return -EILSEQ;
}
break;
case BT_SCO:
break;
default:
panic("unkown packet type in assembly");
break;
}
currentPacketLen = expectedPacketLen; } else {
flowf("ACL frame corrupted\n");
return -EILSEQ;
}
break;
case BT_SCO:
} break;
else {
/* Continuation */ default:
if (type != BT_EVENT) panic("unkown packet type in assembly");
currentPacketLen = get_expected_size(nbuf) - nbuf->size; break;
else }
currentPacketLen = snb_remaining_to_put(snbuf);
}
currentPacketLen = min(currentPacketLen, count); currentPacketLen = expectedPacketLen;
if (type == BT_EVENT) } else {
snb_put(snbuf, data, currentPacketLen); /* Continuation */
if (type != BT_EVENT)
currentPacketLen = get_expected_size(nbuf) - nbuf->size;
else
currentPacketLen = snb_remaining_to_put(snbuf);
}
currentPacketLen = min(currentPacketLen, count);
if (type == BT_EVENT)
snb_put(snbuf, data, currentPacketLen);
else else
nb->append(nbuf, data, currentPacketLen); nb->append(nbuf, data, currentPacketLen);
/* Complete frame? */ /* Complete frame? */
if (type == BT_EVENT && snb_completed(snbuf)) { if (type == BT_EVENT && snb_completed(snbuf)) {
post_packet_up(bdev, type, snbuf); post_packet_up(bdev, type, snbuf);
snbuf = bdev->eventRx = NULL; snbuf = bdev->eventRx = NULL;
}
}
if (type != BT_EVENT && (get_expected_size(nbuf) - nbuf->size) == 0 ) { if (type != BT_EVENT && (get_expected_size(nbuf) - nbuf->size) == 0 ) {
post_packet_up(bdev, type, nbuf); post_packet_up(bdev, type, nbuf);
@@ -141,13 +139,13 @@ assembly_rx(bt_usb_dev* bdev, bt_packet_t type, void *data, int count)
if (type == BT_ACL) if (type == BT_ACL)
debugf("ACL Packet not filled size=%ld expected=%ld\n", nbuf->size, get_expected_size(nbuf)); debugf("ACL Packet not filled size=%ld expected=%ld\n", nbuf->size, get_expected_size(nbuf));
}*/ }*/
/* in case in the pipe there is info about the next buffer ... */ /* in case in the pipe there is info about the next buffer ... */
count -= currentPacketLen; count -= currentPacketLen;
data += currentPacketLen; data += currentPacketLen;
} }
return B_OK; return B_OK;
} }
@@ -163,38 +161,36 @@ event_complete(void* cookie, uint32 status, void* data, uint32 actual_len)
event_complete(void* cookie, status_t status, void* data, size_t actual_len) event_complete(void* cookie, status_t status, void* data, size_t actual_len)
#endif #endif
{ {
bt_usb_dev* bdev = cookie;
bt_usb_dev* bdev = cookie; status_t err;
status_t err;
/* TODO: or not running anymore */
/* TODO: or not running anymore */
if (status == B_CANCELED) if (status == B_CANCELED)
return; return;
if (status != B_OK || actual_len == 0) if (status != B_OK || actual_len == 0)
goto resubmit; goto resubmit;
if ( assembly_rx(cookie, BT_EVENT, data, actual_len) == B_OK ) { if ( assembly_rx(cookie, BT_EVENT, data, actual_len) == B_OK ) {
bdev->stat.successfulTX++; bdev->stat.successfulTX++;
} else { } else {
bdev->stat.errorRX++; bdev->stat.errorRX++;
} }
resubmit: resubmit:
err = usb->queue_interrupt(bdev->intr_in_ep->handle, err = usb->queue_interrupt(bdev->intr_in_ep->handle,
data, bdev->max_packet_size_intr_in , data, bdev->max_packet_size_intr_in ,
event_complete, bdev); event_complete, bdev);
if (err != B_OK) {
reuse_room(&bdev->eventRoom, data);
bdev->stat.rejectedRX++;
debugf("RX event resubmittion failed %s\n",strerror(err));
} else {
bdev->stat.acceptedRX++;
}
if (err != B_OK ) {
reuse_room(&bdev->eventRoom, data);
bdev->stat.rejectedRX++;
debugf("RX event resubmittion failed %s\n",strerror(err));
}
else {
bdev->stat.acceptedRX++;
}
} }
@@ -205,67 +201,64 @@ acl_rx_complete(void* cookie, uint32 status, void* data, uint32 actual_len)
acl_rx_complete(void* cookie, status_t status, void* data, size_t actual_len) acl_rx_complete(void* cookie, status_t status, void* data, size_t actual_len)
#endif #endif
{ {
bt_usb_dev* bdev = cookie; bt_usb_dev* bdev = cookie;
status_t err; status_t err;
/* TODO: or not running anymore? */ /* TODO: or not running anymore? */
if (status == B_CANCELED) if (status == B_CANCELED)
return; return;
if (status != B_OK || actual_len == 0) if (status != B_OK || actual_len == 0)
goto resubmit; goto resubmit;
if (assembly_rx(cookie, BT_ACL, data, actual_len) == B_OK) {
bdev->stat.successfulRX++;
} else {
bdev->stat.errorRX++;
}
if ( assembly_rx(cookie, BT_ACL, data, actual_len) == B_OK ) {
bdev->stat.successfulRX++;
} else {
bdev->stat.errorRX++;
}
resubmit: resubmit:
err = usb->queue_bulk(bdev->bulk_in_ep->handle, data, err = usb->queue_bulk(bdev->bulk_in_ep->handle, data,
max(HCI_MAX_FRAME_SIZE,bdev->max_packet_size_bulk_in), max(HCI_MAX_FRAME_SIZE,bdev->max_packet_size_bulk_in),
acl_rx_complete, (void*) bdev); acl_rx_complete, (void*) bdev);
if (err != B_OK ) { if (err != B_OK) {
reuse_room(&bdev->aclRoom, data); reuse_room(&bdev->aclRoom, data);
bdev->stat.rejectedRX++; bdev->stat.rejectedRX++;
debugf("RX acl resubmittion failed %s\n", strerror(err)); debugf("RX acl resubmittion failed %s\n", strerror(err));
} } else {
else { bdev->stat.acceptedRX++;
bdev->stat.acceptedRX++; }
}
} }
#if 0 #if 0
#pragma mark --- RX --- #pragma mark --- RX ---
#endif #endif
status_t status_t
submit_rx_event(bt_usb_dev* bdev) submit_rx_event(bt_usb_dev* bdev)
{ {
status_t status; status_t status;
size_t size = bdev->max_packet_size_intr_in; size_t size = bdev->max_packet_size_intr_in;
void* buf = alloc_room(&bdev->eventRoom, size); void* buf = alloc_room(&bdev->eventRoom, size);
if (buf == NULL)
return ENOMEM;
status = usb->queue_interrupt(bdev->intr_in_ep->handle, if (buf == NULL)
buf, size , return ENOMEM;
event_complete, (void*) bdev);
if (status != B_OK ) { status = usb->queue_interrupt(bdev->intr_in_ep->handle,
reuse_room(&bdev->eventRoom, buf); // reuse allocated one buf, size ,
bdev->stat.rejectedRX++; event_complete, (void*) bdev);
}
else { if (status != B_OK) {
bdev->stat.acceptedRX++; reuse_room(&bdev->eventRoom, buf); // reuse allocated one
debugf("Accepted RX Event %d\n", bdev->stat.acceptedRX); bdev->stat.rejectedRX++;
} } else {
bdev->stat.acceptedRX++;
return status; debugf("Accepted RX Event %d\n", bdev->stat.acceptedRX);
}
return status;
} }
@@ -273,34 +266,32 @@ status_t
submit_rx_acl(bt_usb_dev* bdev) submit_rx_acl(bt_usb_dev* bdev)
{ {
status_t status; status_t status;
size_t size = max(HCI_MAX_FRAME_SIZE,bdev->max_packet_size_bulk_in); size_t size = max(HCI_MAX_FRAME_SIZE,bdev->max_packet_size_bulk_in);
void* buf = alloc_room(&bdev->aclRoom, size); void* buf = alloc_room(&bdev->aclRoom, size);
if (buf == NULL) if (buf == NULL)
return ENOMEM; return ENOMEM;
status = usb->queue_bulk(bdev->bulk_in_ep->handle, buf, size ,
acl_rx_complete, bdev);
if (status != B_OK ) { status = usb->queue_bulk(bdev->bulk_in_ep->handle, buf, size ,
reuse_room(&bdev->aclRoom, buf); // reuse allocated acl_rx_complete, bdev);
bdev->stat.rejectedRX++;
} if (status != B_OK) {
else { reuse_room(&bdev->aclRoom, buf); // reuse allocated
bdev->stat.acceptedRX++; bdev->stat.rejectedRX++;
} } else {
bdev->stat.acceptedRX++;
return status; }
return status;
} }
status_t status_t
submit_rx_sco(bt_usb_dev* bdev) submit_rx_sco(bt_usb_dev* bdev)
{ {
/* not yet implemented */
/* not yet implemented */ return B_ERROR;
return B_ERROR;
} }
@@ -316,28 +307,26 @@ command_complete(void* cookie, uint32 status, void* data, uint32 actual_len)
command_complete(void* cookie, status_t status, void* data, size_t actual_len) command_complete(void* cookie, status_t status, void* data, size_t actual_len)
#endif #endif
{ {
snet_buffer* snbuf = (snet_buffer*) cookie; snet_buffer* snbuf = (snet_buffer*) cookie;
bt_usb_dev* bdev = snb_cookie(snbuf); bt_usb_dev* bdev = snb_cookie(snbuf);
debugf("%ld %02x:%02x:%02x:\n", actual_len, ((uint8*)data)[0],((uint8*)data)[1],((uint8*)data)[2]); debugf("%ld %02x:%02x:%02x:\n", actual_len, ((uint8*)data)[0],((uint8*)data)[1],((uint8*)data)[2]);
if (status != B_OK) { if (status != B_OK) {
bdev->stat.successfulTX++;
bdev->stat.successfulTX++; bdev->stat.bytesTX += actual_len;
bdev->stat.bytesTX += actual_len; } else {
} bdev->stat.errorTX++;
else { /* the packet has been lost */
bdev->stat.errorTX++; /* too late to requeue it? */
/* the packet has been lost */ }
/* too late to requeue it? */
}
snb_park(&bdev->snetBufferRecycleTrash, snbuf); snb_park(&bdev->snetBufferRecycleTrash, snbuf);
#ifdef BT_RESCHEDULING_AFTER_COMPLETITIONS #ifdef BT_RESCHEDULING_AFTER_COMPLETITIONS
// TODO: check just the empty queues? // TODO: check just the empty queues?
schedTxProcessing(bdev); schedTxProcessing(bdev);
#endif #endif
} }
@@ -347,92 +336,85 @@ acl_tx_complete(void* cookie, uint32 status, void* data, uint32 actual_len)
#else #else
acl_tx_complete(void* cookie, status_t status, void* data, size_t actual_len) acl_tx_complete(void* cookie, status_t status, void* data, size_t actual_len)
#endif #endif
{ {
net_buffer* nbuf = (net_buffer*) cookie;
bt_usb_dev* bdev = GET_DEVICE(nbuf);
net_buffer* nbuf = (net_buffer*) cookie; if (status != B_OK) {
bt_usb_dev* bdev = GET_DEVICE(nbuf);
if (status != B_OK) { bdev->stat.successfulTX++;
bdev->stat.bytesTX += actual_len;
bdev->stat.successfulTX++; } else {
bdev->stat.bytesTX += actual_len; bdev->stat.errorTX++;
} /* the packet has been lost */
else { /* too late to requeue it? */
bdev->stat.errorTX++; }
/* the packet has been lost */
/* too late to requeue it? */ nb_destroy(nbuf);
}
nb_destroy(nbuf);
#ifdef BT_RESCHEDULING_AFTER_COMPLETITIONS #ifdef BT_RESCHEDULING_AFTER_COMPLETITIONS
schedTxProcessing(bdev); schedTxProcessing(bdev);
#endif #endif
} }
#if 0 #if 0
#pragma mark --- TX --- #pragma mark --- TX ---
#endif #endif
status_t status_t
submit_tx_command(bt_usb_dev* bdev, snet_buffer* snbuf) submit_tx_command(bt_usb_dev* bdev, snet_buffer* snbuf)
{ {
status_t err; status_t err;
uint8 bRequestType = bdev->ctrl_req; uint8 bRequestType = bdev->ctrl_req;
uint8 bRequest = 0; uint8 bRequest = 0;
uint16 wIndex = 0; uint16 wIndex = 0;
uint16 value = 0; uint16 value = 0;
uint16 wLength = B_HOST_TO_LENDIAN_INT16(snb_size(snbuf)); uint16 wLength = B_HOST_TO_LENDIAN_INT16(snb_size(snbuf));
if (!GET_BIT(bdev->state, RUNNING) ) { if (!GET_BIT(bdev->state, RUNNING)) {
return B_DEV_NOT_READY; return B_DEV_NOT_READY;
} }
/* set cookie */ /* set cookie */
snb_set_cookie(snbuf, bdev); snb_set_cookie(snbuf, bdev);
err = usb->queue_request(bdev->dev, bRequestType, bRequest, err = usb->queue_request(bdev->dev, bRequestType, bRequest,
value, wIndex, wLength, value, wIndex, wLength,
snb_get(snbuf), wLength //??? snb_get(snbuf), wLength //???
,command_complete, (void*) snbuf); ,command_complete, (void*) snbuf);
if (err != B_OK ) { if (err != B_OK ) {
bdev->stat.rejectedTX++; bdev->stat.rejectedTX++;
} } else {
else { bdev->stat.acceptedTX++;
bdev->stat.acceptedTX++; }
}
return err; return err;
} }
status_t status_t
submit_tx_acl(bt_usb_dev* bdev, net_buffer* nbuf) submit_tx_acl(bt_usb_dev* bdev, net_buffer* nbuf)
{ {
status_t err; status_t err;
/* set cookie */ /* set cookie */
SET_DEVICE(nbuf,bdev->hdev); SET_DEVICE(nbuf,bdev->hdev);
if (!GET_BIT(bdev->state, RUNNING) ) { if (!GET_BIT(bdev->state, RUNNING) ) {
return B_DEV_NOT_READY; return B_DEV_NOT_READY;
} }
err = usb->queue_bulk(bdev->bulk_out_ep->handle,
err = usb->queue_bulk(bdev->bulk_out_ep->handle, nb_get_whole_buffer(nbuf), nbuf->size,
nb_get_whole_buffer(nbuf), nbuf->size, acl_tx_complete, (void*) nbuf);
acl_tx_complete, (void*) nbuf);
if (err != B_OK ) {
bdev->stat.rejectedTX++;
}
else {
bdev->stat.acceptedTX++;
}
return err; if (err != B_OK ) {
bdev->stat.rejectedTX++;
} else {
bdev->stat.acceptedTX++;
}
return err;
} }
@@ -440,11 +422,10 @@ status_t
submit_tx_sco(bt_usb_dev* bdev) submit_tx_sco(bt_usb_dev* bdev)
{ {
if (!GET_BIT(bdev->state, RUNNING) ) { if (!GET_BIT(bdev->state, RUNNING)) {
return B_DEV_NOT_READY; return B_DEV_NOT_READY;
} }
/* not yet implemented */ /* not yet implemented */
return B_ERROR; return B_ERROR;
} }
src/add-ons/kernel/drivers/bluetooth/h2/h2generic/snet_buffer.c
+53 -56
View File
@@ -13,63 +13,62 @@
struct snet_buffer { struct snet_buffer {
struct list_link link; struct list_link link;
uint8* buffer; uint8* buffer;
uint16 allocatedSize; uint16 allocatedSize;
uint16 expectedSize; uint16 expectedSize;
uint16 puttingSize; uint16 puttingSize;
uint16 pullingSize; uint16 pullingSize;
void* cookie;
void* cookie;
}; };
snet_buffer* snet_buffer*
snb_create(uint16 size) snb_create(uint16 size)
{ {
/* TODO: pointer checking */ /* TODO: pointer checking */
#ifdef SNB_BUFFER_ATTACHED #ifdef SNB_BUFFER_ATTACHED
/* Allocating these 2 buffers together might prevent memory fragmentation? */ /* Allocating these 2 buffers together might prevent memory fragmentation? */
snet_buffer* snb = (snet_buffer*) malloc(sizeof(snet_buffer) + size); snet_buffer* snb = (snet_buffer*) malloc(sizeof(snet_buffer) + size);
snb->buffer = ((uint8*)snb) + sizeof(snet_buffer); snb->buffer = ((uint8*)snb) + sizeof(snet_buffer);
#else #else
snet_buffer* snb = malloc(sizeof (snet_buffer)); snet_buffer* snb = malloc(sizeof (snet_buffer));
snb->buffer = malloc(size); snb->buffer = malloc(size);
#endif #endif
snb->pullingSize = snb->puttingSize = 0; snb->pullingSize = snb->puttingSize = 0;
snb->expectedSize = snb->allocatedSize = size; snb->expectedSize = snb->allocatedSize = size;
return snb;
return snb;
} }
void void
snb_put(snet_buffer* snb, void* data, uint16 size) snb_put(snet_buffer* snb, void* data, uint16 size)
{ {
/* TODO: check overflow */ /* TODO: check overflow */
memcpy( &snb->buffer[snb->puttingSize], data, size); memcpy( &snb->buffer[snb->puttingSize], data, size);
snb->puttingSize+=size; snb->puttingSize+=size;
} }
void* void*
snb_pull(snet_buffer* snb, uint16 size) snb_pull(snet_buffer* snb, uint16 size)
{ {
/* TODO: check overflow */ /* TODO: check overflow */
snb->pullingSize+=size; snb->pullingSize+=size;
return &snb->buffer[snb->pullingSize-size]; return &snb->buffer[snb->pullingSize-size];
} }
inline void inline void
snb_reset(snet_buffer* snb) snb_reset(snet_buffer* snb)
{ {
snb->puttingSize = snb->pullingSize = 0; snb->puttingSize = snb->pullingSize = 0;
} }
@@ -80,10 +79,10 @@ snb_free(snet_buffer* snb)
return; return;
#ifdef SNB_BUFFER_ATTACHED #ifdef SNB_BUFFER_ATTACHED
free(snb); free(snb);
#else #else
free(snb->buffer); free(snb->buffer);
free(snb); free(snb);
#endif #endif
} }
@@ -92,90 +91,89 @@ snb_free(snet_buffer* snb)
inline void* inline void*
snb_get(snet_buffer* snb) snb_get(snet_buffer* snb)
{ {
/* TODO: pointer checking */ /* TODO: pointer checking */
return snb->buffer; return snb->buffer;
} }
inline uint16 inline uint16
snb_size(snet_buffer* snb) snb_size(snet_buffer* snb)
{ {
/* TODO: pointer checking */ /* TODO: pointer checking */
return snb->expectedSize; return snb->expectedSize;
} }
inline void* inline void*
snb_cookie(snet_buffer* snb) snb_cookie(snet_buffer* snb)
{ {
/* TODO: pointer checking */ /* TODO: pointer checking */
return snb->cookie; return snb->cookie;
} }
inline void inline void
snb_set_cookie(snet_buffer* snb, void* cookie) snb_set_cookie(snet_buffer* snb, void* cookie)
{ {
/* TODO: pointer checking */ /* TODO: pointer checking */
snb->cookie = cookie; snb->cookie = cookie;
} }
/* Return true if we canot "put" more data in the buffer */ /* Return true if we canot "put" more data in the buffer */
inline bool snb_completed(snet_buffer* snb) inline bool snb_completed(snet_buffer* snb)
{ {
return (snb->expectedSize == snb->puttingSize); return (snb->expectedSize == snb->puttingSize);
} }
/* Return true if we cannot pull more more data from the buffer */ /* Return true if we cannot pull more more data from the buffer */
inline bool snb_finished(snet_buffer* snb) inline bool snb_finished(snet_buffer* snb)
{ {
return (snb->expectedSize == snb->pullingSize); return (snb->expectedSize == snb->pullingSize);
} }
inline uint16 snb_remaining_to_put(snet_buffer* snb) inline uint16 snb_remaining_to_put(snet_buffer* snb)
{ {
return (snb->expectedSize - snb->puttingSize); return (snb->expectedSize - snb->puttingSize);
} }
inline uint16 snb_remaining_to_pull(snet_buffer* snb) inline uint16 snb_remaining_to_pull(snet_buffer* snb)
{ {
return (snb->expectedSize - snb->pullingSize); return (snb->expectedSize - snb->pullingSize);
} }
/* ISSUE1: Number of packets in the worst case(we always need a bigger /* ISSUE1: Number of packets in the worst case(we always need a bigger
buffer than before) increases, never decreases: buffer than before) increases, never decreases:
SOL1: Delete the smallest when the queue is bigger than X elements SOL1: Delete the smallest when the queue is bigger than X elements
SOL2: ? SOL2: ?
ISSUE2: If the queue is not gonna be used for long time. Memory c ISSUE2: If the queue is not gonna be used for long time. Memory c
ould be freed ould be freed
SOL1: Provide purge func. SOL1: Provide purge func.
SOL2: ? SOL2: ?
*/ */
static snet_buffer* static snet_buffer*
snb_attempt_reuse(snet_buffer* snb, uint16 size) snb_attempt_reuse(snet_buffer* snb, uint16 size)
{ {
if ( snb == NULL || if ( snb == NULL ||
((int16)snb->allocatedSize - (int16)size) < 0 ) { ((int16)snb->allocatedSize - (int16)size) < 0 ) {
/* Impossible or not worth, Creating a new one */ /* Impossible or not worth, Creating a new one */
snb_free(snb); snb_free(snb);
return snb_create(size); return snb_create(size);
} } else {
else { snb_reset(snb);
snb_reset(snb); snb->expectedSize = size;
snb->expectedSize = size; return snb;
return snb; }
}
} }
@@ -195,7 +193,6 @@ snb_park(struct list* l, snet_buffer* snb)
snet_buffer* snet_buffer*
snb_fetch(struct list* l, uint16 size) snb_fetch(struct list* l, uint16 size)
{ {
snet_buffer* item = NULL; snet_buffer* item = NULL;
snet_buffer* previous = NULL; snet_buffer* previous = NULL;