Changeset 4abc304 in mainline


Ignore:
Timestamp:
2011-02-28T11:55:36Z (13 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
dced52a
Parents:
299d53e
Message:

Debug output refactored

Location:
uspace/drv/uhci-hcd
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/uhci-hcd/batch.c

    r299d53e r4abc304  
    134134
    135135        queue_head_element_td(instance->qh, addr_to_phys(instance->tds));
     136        usb_log_debug("Batch(%p) %d:%d memory structures ready.\n",
     137            instance, target.address, target.endpoint);
    136138        return instance;
    137139}
    … …  
    196198
    197199        instance->tds[i].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
    198         usb_log_debug("Control write last TD status: %x.\n",
     200        usb_log_debug2("Control write last TD status: %x.\n",
    199201                instance->tds[i].status);
    200202
    201203        instance->next_step = batch_call_out_and_dispose;
     204        usb_log_debug("Batch(%p) CONTROL WRITE initialized.\n", instance);
    202205        batch_schedule(instance);
    203206}
    … …  
    232235
    233236        instance->tds[i].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
    234         usb_log_debug("Control read last TD status: %x.\n",
     237        usb_log_debug2("Control read last TD status: %x.\n",
    235238                instance->tds[i].status);
    236239
    237240        instance->next_step = batch_call_in_and_dispose;
     241        usb_log_debug("Batch(%p) CONTROL READ initialized.\n", instance);
    238242        batch_schedule(instance);
    239243}
    … …  
    261265
    262266        instance->next_step = batch_call_in_and_dispose;
     267        usb_log_debug("Batch(%p) INTERRUPT IN initialized.\n", instance);
    263268        batch_schedule(instance);
    264269}
    … …  
    288293
    289294        instance->next_step = batch_call_out_and_dispose;
     295        usb_log_debug("Batch(%p) INTERRUPT OUT initialized.\n", instance);
    290296        batch_schedule(instance);
    291297}
    … …  
    299305
    300306        int err = instance->error;
    301         usb_log_info("Batch(%p) callback IN(type:%d): %s(%d), %zu.\n",
     307        usb_log_debug("Batch(%p) callback IN(type:%d): %s(%d), %zu.\n",
    302308            instance, instance->transfer_type, str_error(err), err,
    303309            instance->transfered_size);
    … …  
    314320
    315321        int err = instance->error;
    316         usb_log_info("Batch(%p) callback OUT(type:%d): %s(%d).\n",
     322        usb_log_debug("Batch(%p) callback OUT(type:%d): %s(%d).\n",
    317323            instance, instance->transfer_type, str_error(err), err);
    318324        instance->callback_out(instance->fun,

  • uspace/drv/uhci-hcd/pci.c

    r299d53e r4abc304  
    8585                                irq = res->res.interrupt.irq;
    8686                                irq_found = true;
    87                                 usb_log_debug("Found interrupt: %d.\n", irq);
     87                                usb_log_debug2("Found interrupt: %d.\n", irq);
    8888                                break;
    8989                        case IO_RANGE:
    9090                                io_address = res->res.io_range.address;
    9191                                io_size = res->res.io_range.size;
    92                                 usb_log_debug("Found io: %llx %zu %zu.\n",
    93                                     res->res.io_range.address, res->res.io_range.size, io_size);
     92                                usb_log_debug2("Found io: %llx %zu.\n",
     93                                    res->res.io_range.address, res->res.io_range.size);
    9494                                io_found = true;
    9595                                break;

  • uspace/drv/uhci-hcd/root_hub.c

    r299d53e r4abc304  
    3434#include <assert.h>
    3535#include <errno.h>
     36#include <str_error.h>
    3637#include <stdio.h>
    3738#include <ops/hw_res.h>
    … …  
    118119{
    119120        assert(fun);
     121        assert(hc);
    120122        int ret;
    121123
    … …  
    136138        ret = ddf_fun_add_match_id(hub, match_str, 100);
    137139        if (ret != EOK) {
    138                 usb_log_error("Failed to add root hub match id.\n");
     140                usb_log_error("Failed(%d) to add root hub match id: %s\n",
     141                    ret, str_error(ret));
    139142                ddf_fun_destroy(hub);
    140                 return ENOMEM;
     143                return ret;
    141144        }
    142145

  • uspace/drv/uhci-hcd/transfer_list.c

    r299d53e r4abc304  
    7070        assert(instance);
    7171        assert(batch);
    72         usb_log_debug("Adding batch(%p) to queue %s.\n", batch, instance->name);
     72        usb_log_debug2("Adding batch(%p) to queue %s.\n", batch, instance->name);
    7373
    7474        uint32_t pa = (uintptr_t)addr_to_phys(batch->qh);
    … …  
    8484                list_append(&batch->link, &instance->batch_list);
    8585                instance->queue_head->element = pa;
    86                 usb_log_debug2("Added batch(%p) to queue %s first.\n",
     86                usb_log_debug("Batch(%p) added to queue %s first.\n",
    8787                        batch, instance->name);
    8888                fibril_mutex_unlock(&instance->guard);
    … …  
    9797        queue_head_append_qh(last->qh, pa);
    9898        list_append(&batch->link, &instance->batch_list);
    99         usb_log_debug2("Added batch(%p) to queue %s last, first is %p.\n",
     99        usb_log_debug("Batch(%p) added to queue %s last, first is %p.\n",
    100100                batch, instance->name, first );
    101101        fibril_mutex_unlock(&instance->guard);
    … …  
    109109        assert(instance->queue_head);
    110110        assert(batch->qh);
     111        usb_log_debug2("Removing batch(%p) from queue %s.\n", batch, instance->name);
    111112
    112113        /* I'm the first one here */
    113114        if (batch->link.prev == &instance->batch_list) {
    114                 usb_log_debug("Removing batch %p was first, next element %x.\n",
    115                         batch, batch->qh->next_queue);
     115                usb_log_debug("Batch(%p) removed (FIRST) from queue %s, next element %x.\n",
     116                        batch, instance->name, batch->qh->next_queue);
    116117                instance->queue_head->element = batch->qh->next_queue;
    117118        } else {
    118                 usb_log_debug("Removing batch %p was NOT first, next element %x.\n",
    119                         batch, batch->qh->next_queue);
     119                usb_log_debug("Batch(%p) removed (NOT FIRST) from queue, next element %x.\n",
     120                        batch, instance->name, batch->qh->next_queue);
    120121                batch_t *prev = list_get_instance(batch->link.prev, batch_t, link);
    121122                prev->qh->next_queue = batch->qh->next_queue;

  • uspace/drv/uhci-hcd/uhci.c

    r299d53e r4abc304  
    101101        bool low_speed, usb_transfer_type_t, size_t size);
    102102
    103 #define CHECK_RET_RETURN(ret, message...) \
     103
     104int uhci_init(uhci_t *instance, ddf_dev_t *dev, void *regs, size_t reg_size)
     105{
     106        assert(reg_size >= sizeof(regs_t));
     107        int ret;
     108
     109#define CHECK_RET_DEST_FUN_RETURN(ret, message...) \
    104110        if (ret != EOK) { \
    105111                usb_log_error(message); \
     112                if (instance->ddf_instance) \
     113                        ddf_fun_destroy(instance->ddf_instance); \
    106114                return ret; \
    107115        } else (void) 0
    108 
    109 int uhci_init(uhci_t *instance, ddf_dev_t *dev, void *regs, size_t reg_size)
    110 {
    111         assert(reg_size >= sizeof(regs_t));
    112         int ret;
    113116
    114117        /*
    … …  
    116119         */
    117120        instance->ddf_instance = ddf_fun_create(dev, fun_exposed, "uhci");
    118         if (instance->ddf_instance == NULL) {
    119                 usb_log_error("Failed to create UHCI device function.\n");
    120                 return ENOMEM;
    121         }
     121        ret = (instance->ddf_instance == NULL) ? ENOMEM : EOK;
     122        CHECK_RET_DEST_FUN_RETURN(ret, "Failed to create UHCI device function.\n");
     123
    122124        instance->ddf_instance->ops = &uhci_ops;
    123125        instance->ddf_instance->driver_data = instance;
    124126
    125127        ret = ddf_fun_bind(instance->ddf_instance);
    126         CHECK_RET_RETURN(ret, "Failed to bind UHCI device function: %s.\n",
    127             str_error(ret));
     128        CHECK_RET_DEST_FUN_RETURN(ret, "Failed(%d) to bind UHCI device function: %s.\n",
     129            ret, str_error(ret));
    128130
    129131        /* allow access to hc control registers */
    130132        regs_t *io;
    131133        ret = pio_enable(regs, reg_size, (void**)&io);
    132         CHECK_RET_RETURN(ret, "Failed to gain access to registers at %p.\n", io);
     134        CHECK_RET_DEST_FUN_RETURN(ret, "Failed(%d) to gain access to registers at %p: %s.\n",
     135            ret, str_error(ret), io);
    133136        instance->registers = io;
    134         usb_log_debug("Device registers accessible.\n");
     137        usb_log_debug("Device registers at %p(%u) accessible.\n", io, reg_size);
    135138
    136139        ret = uhci_init_mem_structures(instance);
    137         CHECK_RET_RETURN(ret, "Failed to initialize memory structures.\n");
     140        CHECK_RET_DEST_FUN_RETURN(ret, "Failed to initialize UHCI memory structures.\n");
    138141
    139142        uhci_init_hw(instance);
    … …  
    145148        fibril_add_ready(instance->debug_checker);
    146149
    147         return EOK;
     150        usb_log_info("Started UHCI driver.\n");
     151        return EOK;
     152#undef CHECK_RET_DEST_FUN_RETURN
    148153}
    149154/*----------------------------------------------------------------------------*/
    … …  
    171176        pio_write_16(&instance->registers->usbcmd,
    172177            UHCI_CMD_RUN_STOP | UHCI_CMD_MAX_PACKET | UHCI_CMD_CONFIGURE);
    173         usb_log_debug("Started UHCI HC.\n");
    174178}
    175179/*----------------------------------------------------------------------------*/
    … …  
    177181{
    178182        assert(instance);
     183#define CHECK_RET_DEST_CMDS_RETURN(ret, message...) \
     184        if (ret != EOK) { \
     185                usb_log_error(message); \
     186                if (instance->interrupt_code.cmds != NULL) \
     187                        free(instance->interrupt_code.cmds); \
     188                return ret; \
     189        } else (void) 0
    179190
    180191        /* init interrupt code */
    181         irq_cmd_t *interrupt_commands = malloc(sizeof(uhci_cmds));
    182         if (interrupt_commands == NULL) {
    183                 return ENOMEM;
    184         }
    185         memcpy(interrupt_commands, uhci_cmds, sizeof(uhci_cmds));
    186         interrupt_commands[0].addr = (void*)&instance->registers->usbsts;
    187         interrupt_commands[1].addr = (void*)&instance->registers->usbsts;
    188         instance->interrupt_code.cmds = interrupt_commands;
    189         instance->interrupt_code.cmdcount =
    190             sizeof(uhci_cmds) / sizeof(irq_cmd_t);
     192        instance->interrupt_code.cmds = malloc(sizeof(uhci_cmds));
     193        int ret = (instance->interrupt_code.cmds == NULL) ? ENOMEM : EOK;
     194        CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to allocate interrupt cmds space.\n");
     195
     196        {
     197                irq_cmd_t *interrupt_commands = instance->interrupt_code.cmds;
     198                memcpy(interrupt_commands, uhci_cmds, sizeof(uhci_cmds));
     199                interrupt_commands[0].addr = (void*)&instance->registers->usbsts;
     200                interrupt_commands[1].addr = (void*)&instance->registers->usbsts;
     201                instance->interrupt_code.cmdcount =
     202                                sizeof(uhci_cmds) / sizeof(irq_cmd_t);
     203        }
    191204
    192205        /* init transfer lists */
    193         int ret = uhci_init_transfer_lists(instance);
    194         CHECK_RET_RETURN(ret, "Failed to initialize transfer lists.\n");
     206        ret = uhci_init_transfer_lists(instance);
     207        CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to initialize transfer lists.\n");
    195208        usb_log_debug("Initialized transfer lists.\n");
    196209
    … …  
    198211        instance->frame_list = get_page();
    199212        ret = instance ? EOK : ENOMEM;
    200         CHECK_RET_RETURN(ret, "Failed to get frame list page.\n");
     213        CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to get frame list page.\n");
    201214        usb_log_debug("Initialized frame list.\n");
    202215
    … …  
    205218          instance->transfers_interrupt.queue_head_pa
    206219          | LINK_POINTER_QUEUE_HEAD_FLAG;
     220
    207221        unsigned i = 0;
    208222        for(; i < UHCI_FRAME_LIST_COUNT; ++i) {
    … …  
    215229
    216230        return EOK;
     231#undef CHECK_RET_DEST_CMDS_RETURN
    217232}
    218233/*----------------------------------------------------------------------------*/
    … …  
    220235{
    221236        assert(instance);
     237#define CHECK_RET_CLEAR_RETURN(ret, message...) \
     238        if (ret != EOK) { \
     239                usb_log_error(message); \
     240                transfer_list_fini(&instance->transfers_bulk_full); \
     241                transfer_list_fini(&instance->transfers_control_full); \
     242                transfer_list_fini(&instance->transfers_control_slow); \
     243                transfer_list_fini(&instance->transfers_interrupt); \
     244                return ret; \
     245        } else (void) 0
    222246
    223247        /* initialize TODO: check errors */
    224248        int ret;
    225249        ret = transfer_list_init(&instance->transfers_bulk_full, "BULK_FULL");
    226         assert(ret == EOK);
     250        CHECK_RET_CLEAR_RETURN(ret, "Failed to init BULK list.");
    227251        ret = transfer_list_init(&instance->transfers_control_full, "CONTROL_FULL");
    228         assert(ret == EOK);
     252        CHECK_RET_CLEAR_RETURN(ret, "Failed to init CONTROL FULL list.");
    229253        ret = transfer_list_init(&instance->transfers_control_slow, "CONTROL_SLOW");
    230         assert(ret == EOK);
     254        CHECK_RET_CLEAR_RETURN(ret, "Failed to init CONTROL SLOW list.");
    231255        ret = transfer_list_init(&instance->transfers_interrupt, "INTERRUPT");
    232         assert(ret == EOK);
     256        CHECK_RET_CLEAR_RETURN(ret, "Failed to init INTERRUPT list.");
    233257
    234258        transfer_list_set_next(&instance->transfers_control_full,
    … …  
    257281
    258282        return EOK;
     283#undef CHECK_RET_CLEAR_RETURN
    259284}
    260285/*----------------------------------------------------------------------------*/

  • uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.c

    r299d53e r4abc304  
    6767        }
    6868
    69         usb_log_info("Created TD: %X:%X:%X:%X(%p).\n",
     69        usb_log_debug2("Created TD: %X:%X:%X:%X(%p).\n",
    7070                instance->next, instance->status, instance->device,
    7171          instance->buffer_ptr, buffer);
Note: See TracChangeset for help on using the changeset viewer.