Changes in / [9445aad:bdc8ab1] in mainline


Ignore:
Files:
7 deleted
25 edited

Legend:

Unmodified
Added
Removed

  • .bzrignore

    r9445aad rbdc8ab1  
    8989./uspace/drv/usbhid/usbhid
    9090./uspace/drv/usbmid/usbmid
    91 ./uspace/drv/usbmouse/usbmouse
    9291./uspace/drv/vhc/vhc
    9392./uspace/srv/bd/ata_bd/ata_bd

  • Makefile

    r9445aad rbdc8ab1  
    4242CONFIG_HEADER = config.h
    4343
    44 .PHONY: all precheck cscope autotool config_auto config_default config distclean clean check distfile dist
     44.PHONY: all precheck cscope autotool config_auto config_default config distclean clean check
    4545
    4646all: $(COMMON_MAKEFILE) $(COMMON_HEADER) $(CONFIG_MAKEFILE) $(CONFIG_HEADER)
    … …  
    6464endif
    6565
    66 # Autotool (detects compiler features)
    67 
    6866$(COMMON_MAKEFILE): autotool
    6967$(COMMON_HEADER): autotool
    … …  
    7270        $(AUTOTOOL)
    7371        -[ -f $(COMMON_HEADER_PREV) ] && diff -q $(COMMON_HEADER_PREV) $(COMMON_HEADER) && mv -f $(COMMON_HEADER_PREV) $(COMMON_HEADER)
    74 
    75 # Build-time configuration
    7672
    7773$(CONFIG_MAKEFILE): config_default
    … …  
    8884        $(CONFIG) $<
    8985
    90 # Distribution files
    91 
    92 distfile: all
    93         $(MAKE) -C dist distfile
    94 
    95 dist:
    96         $(MAKE) -C dist dist
    97 
    98 # Cleaning
    99 
    10086distclean: clean
    101         rm -f $(CSCOPE).out $(COMMON_MAKEFILE) $(COMMON_HEADER) $(COMMON_HEADER_PREV) $(CONFIG_MAKEFILE) $(CONFIG_HEADER) tools/*.pyc tools/checkers/*.pyc dist/HelenOS-*
     87        rm -f $(CSCOPE).out $(COMMON_MAKEFILE) $(COMMON_HEADER) $(COMMON_HEADER_PREV) $(CONFIG_MAKEFILE) $(CONFIG_HEADER) tools/*.pyc tools/checkers/*.pyc
    10288
    10389clean:

  • boot/arch/amd64/Makefile.inc

    r9445aad rbdc8ab1  
    4848        usbhid \
    4949        usbmid \
    50         usbmouse \
    5150        vhc
    5251

  • boot/arch/sparc64/include/arch.h

    r9445aad rbdc8ab1  
    4141#define STACK_BIAS                   2047
    4242#define STACK_WINDOW_SAVE_AREA_SIZE  (16 * 8)
    43 #define STACK_ARG_SAVE_AREA_SIZE     (6 * 8)
    4443
    4544#define NWINDOWS  8

  • boot/arch/sparc64/src/asm.S

    r9445aad rbdc8ab1  
    152152.global ofw
    153153ofw:
    154         save %sp, -(STACK_WINDOW_SAVE_AREA_SIZE + STACK_ARG_SAVE_AREA_SIZE), %sp
     154        save %sp, -STACK_WINDOW_SAVE_AREA_SIZE, %sp
    155155        set ofw_cif, %l0
    156156        ldx [%l0], %l0

  • boot/arch/sparc64/src/main.c

    r9445aad rbdc8ab1  
    190190        bootinfo.memmap.zones[0].start += OBP_BIAS;
    191191        bootinfo.memmap.zones[0].size -= OBP_BIAS;
    192         bootinfo.memmap.total -= OBP_BIAS;
    193192}
    194193
    … …  
    205204        bootinfo.physmem_start = ofw_get_physmem_start();
    206205        ofw_memmap(&bootinfo.memmap);
    207 
    208         if (arch == ARCH_SUN4V)
    209                 sun4v_fixups();
    210206       
    211207        void *bootinfo_pa = ofw_translate(&bootinfo);
    … …  
    257253               
    258254                /*
    259                  * At this point, we claim and map the physical memory that we
    260                  * are going to use. We should be safe in case of the virtual
     255                 * At this point, we claim the physical memory that we are
     256                 * going to use. We should be safe in case of the virtual
    261257                 * address space because the OpenFirmware, according to its
    262                  * SPARC binding, should restrict its use of virtual memory to
    263                  * addresses from [0xffd00000; 0xffefffff] and [0xfe000000;
    264                  * 0xfeffffff].
     258                 * SPARC binding, should restrict its use of virtual memory
     259                 * to addresses from [0xffd00000; 0xffefffff] and
     260                 * [0xfe000000; 0xfeffffff].
     261                 *
     262                 * We don't map this piece of memory. We simply rely on
     263                 * SILO to have it done for us already in this case.
     264                 *
     265                 * XXX SILO only maps 8 MB for us here. We should improve
     266                 *     this code to be totally independent on the behavior
     267                 *     of SILO.
     268                 *
    265269                 */
    266270                ofw_claim_phys(bootinfo.physmem_start + dest[i - 1],
    267271                    ALIGN_UP(components[i - 1].inflated, PAGE_SIZE));
    268                
    269                 ofw_map(bootinfo.physmem_start + dest[i - 1], dest[i - 1],
    270                     ALIGN_UP(components[i - 1].inflated, PAGE_SIZE), -1);
    271272               
    272273                int err = inflate(components[i - 1].start, components[i - 1].size,
    … …  
    303304                sun4u_smp();
    304305       
     306        if (arch == ARCH_SUN4V)
     307                sun4v_fixups();
     308       
    305309        printf("Booting the kernel ...\n");
    306310        jump_to_kernel(bootinfo.physmem_start | BSP_PROCESSOR, &bootinfo, subarch,

  • boot/generic/src/balloc.c

    r9445aad rbdc8ab1  
    6565void *balloc_rebase(void *ptr)
    6666{
    67         return (void *) (((uintptr_t) ptr - phys_base) + ballocs->base);
     67        return (void *) ((uintptr_t) ptr - phys_base + ballocs->base);
    6868}

  • kernel/arch/sparc64/src/sun4v/asm.S

    r9445aad rbdc8ab1  
    4141.global switch_to_userspace
    4242switch_to_userspace:
    43         save %o1, -(STACK_WINDOW_SAVE_AREA_SIZE + STACK_ARG_SAVE_AREA_SIZE), %sp
     43        wrpr PSTATE_PRIV_BIT, %pstate
     44        save %o1, -STACK_WINDOW_SAVE_AREA_SIZE, %sp
    4445        flushw
    4546        wrpr %g0, 0, %cleanwin          ! avoid information leak

  • tools/toolchain.sh

    r9445aad rbdc8ab1  
    2828# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2929#
    30 
    31 GMP_MAIN=<<EOF
    32 #define GCC_GMP_VERSION_NUM(a, b, c) \
    33         (((a) << 16L) | ((b) << 8) | (c))
    34 
    35 #define GCC_GMP_VERSION \
    36         GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL)
    37 
    38 #if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,2)
    39         choke me
    40 #endif
    41 EOF
    42 
    43 MPFR_MAIN=<<EOF
    44 #if MPFR_VERSION < MPFR_VERSION_NUM(2, 4, 2)
    45 choke me
    46         #endif
    47 EOF
    48 
    49 MPC_MAIN=<<EOF
    50 #if MPC_VERSION < MPC_VERSION_NUM(0, 8, 1)
    51         choke me
    52 #endif
    53 EOF
    54 
    55 #
    56 # Check if the library described in the argument
    57 # exists and has acceptable version.
    58 #
    59 check_dependency() {
    60         DEPENDENCY="$1"
    61         HEADER="$2"
    62         BODY="$3"
    63        
    64         FNAME="/tmp/conftest-$$"
    65        
    66         echo "#include ${HEADER}" > "${FNAME}.c"
    67         echo >> "${FNAME}.c"
    68         echo "int main()" >> "${FNAME}.c"
    69         echo "{" >> "${FNAME}.c"
    70         echo "${BODY}" >> "${FNAME}.c"
    71         echo "  return 0;" >> "${FNAME}.c"
    72         echo "}" >> "${FNAME}.c"
    73        
    74         cc -c -o "${FNAME}.o" "${FNAME}.c" 2> "${FNAME}.log"
    75         RC="$?"
    76        
    77         if [ "$RC" -ne "0" ] ; then
    78                 echo " ${DEPENDENCY} not found, too old or compiler error."
    79                 echo " Please recheck manually the source file \"${FNAME}.c\"."
    80                 echo " The compilation of the toolchain is probably going to fail,"
    81                 echo " you have been warned."
    82                 echo
    83                 echo " ===== Compiler output ====="
    84                 cat "${FNAME}.log"
    85                 echo " ==========================="
    86                 echo
    87         else
    88                 echo " ${DEPENDENCY} found"
    89                 rm -f "${FNAME}.log" "${FNAME}.o" "${FNAME}.c"
    90         fi
    91 }
    92 
    93 check_dependecies() {
    94         echo ">>> Basic dependency check"
    95         check_dependency "GMP" "<gmp.h>" "${GMP_MAIN}"
    96         check_dependency "MPFR" "<mpfr.h>" "${MPFR_MAIN}"
    97         check_dependency "MPC" "<mpc.h>" "${MPC_MAIN}"
    98         echo
    99 }
    10030
    10131check_error() {
    … …  
    13969        echo " sparc64    SPARC V9"
    14070        echo " all        build all targets"
    141         echo
    142         echo "The toolchain will be installed to the directory specified by"
    143         echo "the CROSS_PREFIX environment variable. If the variable is not"
    144         echo "defined, /usr/local will be used by default."
    14571        echo
    14672       
    … …  
    192118        echo " - native C library with headers"
    193119        echo
     120       
     121        show_countdown 10
    194122}
    195123
    … …  
    353281
    354282show_dependencies
    355 check_dependecies
    356 show_countdown 10
    357283
    358284case "$1" in

  • uspace/Makefile

    r9445aad rbdc8ab1  
    122122                drv/usbhub \
    123123                drv/usbmid \
    124                 drv/usbmouse \
    125124                drv/vhc
    126125endif
    … …  
    139138                drv/usbhub \
    140139                drv/usbmid \
    141                 drv/usbmouse \
    142140                drv/vhc
    143141endif

  • uspace/app/bdsh/cmds/modules/mount/mount.c

    r9445aad rbdc8ab1  
    3131#include <vfs/vfs.h>
    3232#include <errno.h>
    33 #include <getopt.h>
    3433#include "config.h"
    3534#include "util.h"
    … …  
    4140static const char *cmdname = "mount";
    4241
    43 static struct option const long_options[] = {
    44         { "help", no_argument, 0, 'h' },
    45         { 0, 0, 0, 0 }
    46 };
    47 
    48 
    49 /* Displays help for mount in various levels */
     42/* Dispays help for mount in various levels */
    5043void help_cmd_mount(unsigned int level)
    5144{
    … …  
    6659        unsigned int argc;
    6760        const char *mopts = "";
    68         int rc, c, opt_ind;
     61        int rc;
    6962
    7063        argc = cli_count_args(argv);
    7164
    72         for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
    73                 c = getopt_long(argc, argv, "h", long_options, &opt_ind);
    74                 switch (c) {
    75                 case 'h':
    76                         help_cmd_mount(HELP_LONG);
    77                         return CMD_SUCCESS;
    78                 }
    79         }
    80 
    8165        if ((argc < 4) || (argc > 5)) {
    82                 printf("%s: invalid number of arguments. Try `mount --help'\n",
     66                printf("%s: invalid number of arguments.\n",
    8367                    cmdname);
    8468                return CMD_FAILURE;

  • uspace/doc/doxygroups.h

    r9445aad rbdc8ab1  
    245245
    246246        /**
    247          * @defgroup drvusbmouse USB mouse driver
    248          * @ingroup usb
    249          * @brief USB driver for mouse with boot protocol.
    250          */
    251 
    252         /**
    253247         * @defgroup drvusbuhci UHCI driver
    254248         * @ingroup usb

  • uspace/drv/usbhid/hiddev.c

    r9445aad rbdc8ab1  
    149149        usb_log_info("Processing descriptors...\n");
    150150       
     151        // get the first configuration descriptor
     152        usb_standard_configuration_descriptor_t config_desc;
     153       
    151154        int rc;
    152 
    153         uint8_t *descriptors = NULL;
    154         size_t descriptors_size;
    155         rc = usb_request_get_full_configuration_descriptor_alloc(
    156             &hid_dev->ctrl_pipe, 0, (void **) &descriptors, &descriptors_size);
    157         if (rc != EOK) {
    158                 usb_log_error("Failed to retrieve config descriptor: %s.\n",
    159                     str_error(rc));
    160                 return rc;
     155        rc = usb_request_get_bare_configuration_descriptor(&hid_dev->ctrl_pipe,
     156            0, &config_desc);
     157       
     158        if (rc != EOK) {
     159                usb_log_error("Failed to get bare config descriptor: %s.\n",
     160                    str_error(rc));
     161                return rc;
     162        }
     163       
     164        // prepare space for all underlying descriptors
     165        uint8_t *descriptors = (uint8_t *)malloc(config_desc.total_length);
     166        if (descriptors == NULL) {
     167                usb_log_error("No memory!.\n");
     168                return ENOMEM;
     169        }
     170       
     171        size_t transferred = 0;
     172        // get full configuration descriptor
     173        rc = usb_request_get_full_configuration_descriptor(&hid_dev->ctrl_pipe,
     174            0, descriptors, config_desc.total_length, &transferred);
     175       
     176        if (rc != EOK) {
     177                usb_log_error("Failed to get full config descriptor: %s.\n",
     178                    str_error(rc));
     179                free(descriptors);
     180                return rc;
     181        }
     182       
     183        if (transferred != config_desc.total_length) {
     184                usb_log_error("Configuration descriptor has wrong size (%u, "
     185                    "expected %u).\n", transferred, config_desc.total_length);
     186                free(descriptors);
     187                return ELIMIT;
    161188        }
    162189       
    … …  
    174201       
    175202        rc = usb_endpoint_pipe_initialize_from_configuration(
    176             endpoint_mapping, 1, descriptors, descriptors_size,
     203            endpoint_mapping, 1, descriptors, config_desc.total_length,
    177204            &hid_dev->wire);
    178205       
    … …  
    206233        assert(endpoint_mapping[0].interface != NULL);
    207234       
    208         rc = usbhid_dev_get_report_descriptor(hid_dev,
    209             descriptors, descriptors_size,
     235        rc = usbhid_dev_get_report_descriptor(hid_dev, descriptors, transferred,
    210236            (uint8_t *)endpoint_mapping[0].interface);
    211237       

  • uspace/drv/usbhid/kbddev.c

    r9445aad rbdc8ab1  
    289289
    290290        usb_log_debug2("Sending key %d to the console\n", ev.key);
    291         if (kbd_dev->console_phone < 0) {
    292                 usb_log_warning(
    293                     "Connection to console not ready, key discarded.\n");
    294                 return;
    295         }
     291        assert(kbd_dev->console_phone != -1);
    296292       
    297293        async_msg_4(kbd_dev->console_phone, KBD_EVENT, ev.type, ev.key,

  • uspace/drv/usbhid/usbhid.ma

    r9445aad rbdc8ab1  
    1 100 usb&interface&class=HID&subclass=0x01&protocol=0x01
     110 usb&class=hid
     210 usb&class=HID
    2310 usb&interface&class=HID
     410 usb&hid

  • uspace/drv/usbhub/usbhub.c

    r9445aad rbdc8ab1  
    149149        }
    150150
    151         /* Retrieve full configuration descriptor. */
    152         uint8_t *descriptors = NULL;
    153         size_t descriptors_size = 0;
    154         opResult = usb_request_get_full_configuration_descriptor_alloc(
     151        //configuration descriptor
     152        /// \TODO check other configurations?
     153        usb_standard_configuration_descriptor_t config_descriptor;
     154        opResult = usb_request_get_bare_configuration_descriptor(
    155155            &hub->endpoints.control, 0,
    156             (void **) &descriptors, &descriptors_size);
    157         if (opResult != EOK) {
    158                 usb_log_error("Could not get configuration descriptor: %s.\n",
    159                     str_error(opResult));
     156        &config_descriptor);
     157        if(opResult!=EOK){
     158                dprintf(USB_LOG_LEVEL_ERROR, "could not get configuration descriptor, %d",opResult);
    160159                return opResult;
    161160        }
    162         usb_standard_configuration_descriptor_t *config_descriptor
    163             = (usb_standard_configuration_descriptor_t *) descriptors;
    164 
    165         /* Set configuration. */
     161        //set configuration
    166162        opResult = usb_request_set_configuration(&hub->endpoints.control,
    167             config_descriptor->configuration_number);
    168 
    169         if (opResult != EOK) {
    170                 usb_log_error("Failed to set hub configuration: %s.\n",
    171                     str_error(opResult));
     163                config_descriptor.configuration_number);
     164
     165        if (opResult != EOK) {
     166                dprintf(USB_LOG_LEVEL_ERROR,
     167                                "something went wrong when setting hub`s configuration, %d",
     168                                opResult);
    172169                return opResult;
    173170        }
    174171        dprintf(USB_LOG_LEVEL_DEBUG, "\tused configuration %d",
    175                         config_descriptor->configuration_number);
     172                        config_descriptor.configuration_number);
     173
     174        //full configuration descriptor
     175        size_t transferred = 0;
     176        uint8_t * descriptors = (uint8_t *)malloc(config_descriptor.total_length);
     177        if (descriptors == NULL) {
     178                dprintf(USB_LOG_LEVEL_ERROR, "insufficient memory");
     179                return ENOMEM;
     180        }
     181        opResult = usb_request_get_full_configuration_descriptor(&hub->endpoints.control,
     182            0, descriptors,
     183            config_descriptor.total_length, &transferred);
     184        if(opResult!=EOK){
     185                free(descriptors);
     186                dprintf(USB_LOG_LEVEL_ERROR,
     187                                "could not get full configuration descriptor, %d",opResult);
     188                return opResult;
     189        }
     190        if (transferred != config_descriptor.total_length) {
     191                dprintf(USB_LOG_LEVEL_ERROR,
     192                                "received incorrect full configuration descriptor");
     193                return ELIMIT;
     194        }
    176195
    177196        usb_endpoint_mapping_t endpoint_mapping[1] = {
    … …  
    185204        opResult = usb_endpoint_pipe_initialize_from_configuration(
    186205            endpoint_mapping, 1,
    187             descriptors, descriptors_size,
     206            descriptors, config_descriptor.total_length,
    188207            &hub->device_connection);
    189208        if (opResult != EOK) {

  • uspace/drv/usbmid/explore.c

    r9445aad rbdc8ab1  
    4242#include "usbmid.h"
    4343
     44/** Allocate and retrieve full configuration descriptor.
     45 *
     46 * @param[in] dev USB device.
     47 * @param[in] config_index Configuration index.
     48 * @param[out] size Pointer where to store size of the allocated buffer.
     49 * @return Allocated full configuration descriptor.
     50 * @retval NULL Error occured.
     51 */
     52static void *get_configuration_descriptor(usbmid_device_t *dev,
     53    size_t config_index, size_t *size)
     54{
     55        usb_standard_configuration_descriptor_t config_descriptor;
     56        int rc = usb_request_get_bare_configuration_descriptor(&dev->ctrl_pipe,
     57            config_index, &config_descriptor);
     58        if (rc != EOK) {
     59                usb_log_error("Failed getting configuration descriptor: %s.\n",
     60                    str_error(rc));
     61                return NULL;
     62        }
     63
     64        void *full_config_descriptor = malloc(config_descriptor.total_length);
     65        if (full_config_descriptor == NULL) {
     66                usb_log_fatal("Out of memory (wanted: %zuB).\n",
     67                    (size_t) config_descriptor.total_length);
     68                return NULL;
     69        }
     70
     71        size_t full_config_descriptor_size;
     72        rc = usb_request_get_full_configuration_descriptor(&dev->ctrl_pipe,
     73            config_index,
     74            full_config_descriptor, config_descriptor.total_length,
     75            &full_config_descriptor_size);
     76        if (rc != EOK) {
     77                usb_log_error("Failed getting configuration descriptor: %s.\n",
     78                    str_error(rc));
     79                free(full_config_descriptor);
     80                return NULL;
     81        }
     82
     83        if (full_config_descriptor_size != config_descriptor.total_length) {
     84                usb_log_error("Failed getting full configuration descriptor.\n");
     85                free(full_config_descriptor);
     86                return NULL;
     87        }
     88
     89        if (size != NULL) {
     90                *size = full_config_descriptor_size;
     91        }
     92
     93        return full_config_descriptor;
     94}
     95
    4496/** Find starting indexes of all interface descriptors in a configuration.
    4597 *
    … …  
    126178
    127179        size_t config_descriptor_size;
    128         uint8_t *config_descriptor_raw = NULL;
    129         rc = usb_request_get_full_configuration_descriptor_alloc(
    130             &dev->ctrl_pipe, 0,
    131             (void **) &config_descriptor_raw, &config_descriptor_size);
    132         if (rc != EOK) {
    133                 usb_log_error("Failed getting full config descriptor: %s.\n",
    134                     str_error(rc));
     180        uint8_t *config_descriptor_raw = get_configuration_descriptor(dev, 0,
     181            &config_descriptor_size);
     182        if (config_descriptor_raw == NULL) {
    135183                return false;
    136184        }
    … …  
    159207        }
    160208
    161         /* Select the first configuration */
    162         rc = usb_request_set_configuration(&dev->ctrl_pipe,
    163             config_descriptor->configuration_number);
    164         if (rc != EOK) {
    165                 usb_log_error("Failed to set device configuration: %s.\n",
    166                     str_error(rc));
    167                 free(config_descriptor_raw);
    168                 free(interface_descriptors);
    169                 return false;
    170         }
    171 
    172 
    173         /* Create control function */
    174209        ddf_fun_t *ctl_fun = ddf_fun_create(dev->dev, fun_exposed, "ctl");
    175210        if (ctl_fun == NULL) {
    … …  
    188223        }
    189224
    190         /* Spawn interface children */
    191225        size_t i;
    192226        for (i = 0; i < interface_descriptors_count; i++) {

  • uspace/lib/c/generic/loader.c

    r9445aad rbdc8ab1  
    160160        int rc = async_data_write_start(ldr->phone_id, (void *) pa, pa_len);
    161161        if (rc != EOK) {
    162                 free(pa);
    163162                async_wait_for(req, NULL);
    164163                return rc;

  • uspace/lib/c/generic/vfs/vfs.c

    r9445aad rbdc8ab1  
    6969        char *ncwd_path;
    7070        char *ncwd_path_nc;
    71         size_t total_size;
    7271
    7372        fibril_mutex_lock(&cwd_mutex);
    … …  
    7877                        return NULL;
    7978                }
    80                 total_size = cwd_size + 1 + size + 1;
    81                 ncwd_path_nc = malloc(total_size);
     79                ncwd_path_nc = malloc(cwd_size + 1 + size + 1);
    8280                if (!ncwd_path_nc) {
    8381                        fibril_mutex_unlock(&cwd_mutex);
    8482                        return NULL;
    8583                }
    86                 str_cpy(ncwd_path_nc, total_size, cwd_path);
     84                str_cpy(ncwd_path_nc, cwd_size + 1 + size + 1, cwd_path);
    8785                ncwd_path_nc[cwd_size] = '/';
    8886                ncwd_path_nc[cwd_size + 1] = '\0';
    8987        } else {
    90                 total_size = size + 1;
    91                 ncwd_path_nc = malloc(total_size);
     88                ncwd_path_nc = malloc(size + 1);
    9289                if (!ncwd_path_nc) {
    9390                        fibril_mutex_unlock(&cwd_mutex);
    … …  
    9693                ncwd_path_nc[0] = '\0';
    9794        }
    98         str_append(ncwd_path_nc, total_size, path);
     95        str_append(ncwd_path_nc, cwd_size + 1 + size + 1, path);
    9996        ncwd_path = canonify(ncwd_path_nc, retlen);
    10097        if (!ncwd_path) {

  • uspace/lib/usb/include/usb/request.h

    r9445aad rbdc8ab1  
    106106int usb_request_get_full_configuration_descriptor(usb_endpoint_pipe_t *, int,
    107107    void *, size_t, size_t *);
    108 int usb_request_get_full_configuration_descriptor_alloc(usb_endpoint_pipe_t *,
    109     int, void **, size_t *);
    110108int usb_request_set_configuration(usb_endpoint_pipe_t *, uint8_t);
    111109

  • uspace/lib/usb/src/request.c

    r9445aad rbdc8ab1  
    412412}
    413413
    414 /** Retrieve full configuration descriptor, allocate space for it.
    415  *
    416  * The function takes care that full configuration descriptor is returned
    417  * (i.e. the function will fail when less data then descriptor.totalLength
    418  * is returned).
    419  *
    420  * @param[in] pipe Control endpoint pipe (session must be already started).
    421  * @param[in] index Configuration index.
    422  * @param[out] descriptor_ptr Where to store pointer to allocated buffer.
    423  * @param[out] descriptor_size Where to store the size of the descriptor.
    424  * @return Error code.
    425  */
    426 int usb_request_get_full_configuration_descriptor_alloc(
    427     usb_endpoint_pipe_t *pipe, int index,
    428     void **descriptor_ptr, size_t *descriptor_size)
    429 {
    430         int rc;
    431 
    432         if (descriptor_ptr == NULL) {
    433                 return EBADMEM;
    434         }
    435 
    436         usb_standard_configuration_descriptor_t bare_config;
    437         rc = usb_request_get_bare_configuration_descriptor(pipe, index,
    438             &bare_config);
    439         if (rc != EOK) {
    440                 return rc;
    441         }
    442 
    443         if (bare_config.descriptor_type != USB_DESCTYPE_CONFIGURATION) {
    444                 return ENOENT;
    445         }
    446         if (bare_config.total_length < sizeof(bare_config)) {
    447                 return ELIMIT;
    448         }
    449 
    450         void *buffer = malloc(bare_config.total_length);
    451         if (buffer == NULL) {
    452                 return ENOMEM;
    453         }
    454 
    455         size_t transferred = 0;
    456         rc = usb_request_get_full_configuration_descriptor(pipe, index,
    457             buffer, bare_config.total_length, &transferred);
    458         if (rc != EOK) {
    459                 free(buffer);
    460                 return rc;
    461         }
    462 
    463         if (transferred != bare_config.total_length) {
    464                 free(buffer);
    465                 return ELIMIT;
    466         }
    467 
    468         /* Everything looks okay, copy the pointers. */
    469 
    470         *descriptor_ptr = buffer;
    471 
    472         if (descriptor_size != NULL) {
    473                 *descriptor_size = bare_config.total_length;
    474         }
    475 
    476         return EOK;
    477 }
    478 
    479414/** Set configuration of USB device.
    480415 *
    … …  
    569504 *
    570505 * @param[in] pipe Control endpoint pipe (session must be already started).
    571  * @param[in] index String index (in native endianess),
    572  *      first index has number 1 (index from descriptors can be used directly).
     506 * @param[in] index String index (in native endianess).
    573507 * @param[in] lang String language (in native endianess).
    574508 * @param[out] string_ptr Where to store allocated string in native encoding.
    … …  
    581515                return EBADMEM;
    582516        }
    583         /*
    584          * Index is actually one byte value and zero index is used
    585          * to retrieve list of supported languages.
    586          */
    587         if ((index < 1) || (index > 0xFF)) {
     517        /* Index is actually one byte value. */
     518        if (index > 0xFF) {
    588519                return ERANGE;
    589520        }

  • uspace/srv/devmap/devmap.c

    r9445aad rbdc8ab1  
    123123static devmap_handle_t last_handle = 0;
    124124static devmap_device_t *null_devices[NULL_DEVICES];
    125 
    126 /*
    127  * Dummy list for null devices. This is necessary so that null devices can
    128  * be used just as any other devices, e.g. in devmap_device_unregister_core().
    129  */
    130 static LIST_INITIALIZE(dummy_null_driver_devices);
    131125
    132126static devmap_handle_t devmap_create_handle(void)
    … …  
    959953        device->name = dev_name;
    960954       
    961         /*
    962          * Insert device into list of all devices and into null devices array.
    963          * Insert device into a dummy list of null driver's devices so that it
    964          * can be safely removed later.
    965          */
     955        /* Insert device into list of all devices
     956           and into null devices array */
    966957        list_append(&device->devices, &devices_list);
    967         list_append(&device->driver_devices, &dummy_null_driver_devices);
    968958        null_devices[i] = device;
    969959       

  • uspace/srv/fs/fat/fat_dentry.c

    r9445aad rbdc8ab1  
    4242static bool is_d_char(const char ch)
    4343{
    44         if (isalnum(ch) || ch == '_' || ch == '-')
     44        if (isalnum(ch) || ch == '_')
    4545                return true;
    4646        else

  • uspace/srv/fs/fat/fat_ops.c

    r9445aad rbdc8ab1  
    325325                    uint16_t_le2host(d->firstc));
    326326                if (rc != EOK) {
    327                         (void) block_put(b);
    328327                        (void) fat_node_put(FS_NODE(nodep));
    329328                        return rc;
    … …  
    812811        fibril_mutex_unlock(&childp->idx->lock);
    813812        childp->lnkcnt = 0;
    814         childp->refcnt++;       /* keep the node in memory until destroyed */
    815813        childp->dirty = true;
    816814        fibril_mutex_unlock(&childp->lock);
    … …  
    14901488        fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    14911489        fs_node_t *fn;
    1492         fat_node_t *nodep;
    14931490        int rc;
    14941491
    … …  
    15021499                return;
    15031500        }
    1504 
    1505         nodep = FAT_NODE(fn);
    1506         /*
    1507          * We should have exactly two references. One for the above
    1508          * call to fat_node_get() and one from fat_unlink().
    1509          */
    1510         assert(nodep->refcnt == 2);
    15111501
    15121502        rc = fat_destroy_node(fn);

  • uspace/srv/hid/console/console.c

    r9445aad rbdc8ab1  
    4141#include <ipc/ns.h>
    4242#include <errno.h>
    43 #include <str_error.h>
    4443#include <ipc/console.h>
    4544#include <unistd.h>
    … …  
    6564#define NAME       "console"
    6665#define NAMESPACE  "term"
    67 /** Interval for checking for new keyboard (1/4s). */
    68 #define HOTPLUG_WATCH_INTERVAL (1000 * 250)
    6966
    7067/** Phone to the keyboard driver. */
    … …  
    715712}
    716713
    717 static int connect_keyboard_or_mouse(const char *devname,
    718     async_client_conn_t handler, const char *path)
     714static int connect_keyboard(char *path)
    719715{
    720716        int fd = open(path, O_RDONLY);
    … …  
    729725        }
    730726       
    731         int rc = async_connect_to_me(phone, SERVICE_CONSOLE, 0, 0, handler);
     727        /* NB: The callback connection is slotted for removal */
     728        sysarg_t phonehash;
     729        sysarg_t taskhash;
     730        int rc = async_req_3_5(phone, IPC_M_CONNECT_TO_ME, SERVICE_CONSOLE,
     731            0, 0, NULL, NULL, NULL, &taskhash, &phonehash);
    732732        if (rc != EOK) {
    733                 printf(NAME ": " \
    734                     "Failed to create callback from input device: %s.\n",
    735                     str_error(rc));
     733                printf(NAME ": Failed to create callback from input device\n");
    736734                return rc;
    737735        }
    738736       
    739         printf(NAME ": found %s \"%s\".\n", devname, path);
     737        async_new_connection(taskhash, phonehash, 0, NULL, keyboard_events);
     738
     739        printf(NAME ": we got a hit (new keyboard \"%s\").\n", path);
    740740
    741741        return phone;
    742742}
    743743
    744 static int connect_keyboard(const char *path)
    745 {
    746         return connect_keyboard_or_mouse("keyboard", keyboard_events, path);
    747 }
    748 
    749 static int connect_mouse(const char *path)
    750 {
    751         return connect_keyboard_or_mouse("mouse", mouse_events, path);
    752 }
    753 
    754 struct hid_class_info {
    755         char *classname;
    756         int (*connection_func)(const char *);
    757 };
    758 
    759 /** Periodically check for new keyboards in /dev/class/.
     744/** Try to connect to given keyboard, bypassing provided libc routines.
    760745 *
    761  * @param arg Class name.
    762  * @return This function should never exit.
     746 * @param devmap_path Path to keyboard without /dev prefix.
     747 * @return Phone or error code.
    763748 */
    764 static int check_new_device_fibril(void *arg)
    765 {
    766         struct hid_class_info *dev_info = arg;
    767 
    768         size_t index = 1;
     749static int connect_keyboard_bypass(char *devmap_path)
     750{
     751        int devmap_phone = async_connect_me_to_blocking(PHONE_NS,
     752            SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
     753        if (devmap_phone < 0) {
     754                return devmap_phone;
     755        }
     756        ipc_call_t answer;
     757        aid_t req = async_send_2(devmap_phone, DEVMAP_DEVICE_GET_HANDLE,
     758            0, 0,  &answer);
     759
     760        sysarg_t retval = async_data_write_start(devmap_phone,
     761            devmap_path, str_size(devmap_path));
     762        if (retval != EOK) {
     763                async_wait_for(req, NULL);
     764                async_hangup(devmap_phone);
     765                return retval;
     766        }
     767
     768        async_wait_for(req, &retval);
     769
     770        if (retval != EOK) {
     771                async_hangup(devmap_phone);
     772                return retval;
     773        }
     774
     775        devmap_handle_t handle = (devmap_handle_t) IPC_GET_ARG1(answer);
     776
     777        async_hangup(devmap_phone);
     778
     779        int phone = async_connect_me_to(PHONE_NS,
     780            SERVICE_DEVMAP, DEVMAP_CONNECT_TO_DEVICE, handle);
     781        if (phone < 0) {
     782                return phone;
     783        }
     784
     785        /* NB: The callback connection is slotted for removal */
     786        sysarg_t phonehash;
     787        sysarg_t taskhash;
     788        int rc = async_req_3_5(phone, IPC_M_CONNECT_TO_ME, SERVICE_CONSOLE,
     789            0, 0, NULL, NULL, NULL, &taskhash, &phonehash);
     790        if (rc != EOK) {
     791                printf(NAME ": Failed to create callback from input device\n");
     792                return rc;
     793        }
     794
     795        async_new_connection(taskhash, phonehash, 0, NULL, keyboard_events);
     796
     797        printf(NAME ": we got a hit (new keyboard \"/dev/%s\").\n",
     798            devmap_path);
     799
     800        return phone;
     801}
     802
     803
     804static int check_new_keyboards(void *arg)
     805{
     806        char *class_name = (char *) arg;
     807
     808        int index = 1;
    769809
    770810        while (true) {
    771                 async_usleep(HOTPLUG_WATCH_INTERVAL);
     811                async_usleep(1 * 500 * 1000);
    772812                char *path;
    773                 int rc = asprintf(&path, "/dev/class/%s\\%zu",
    774                     dev_info->classname, index);
     813                int rc = asprintf(&path, "class/%s\\%d", class_name, index);
    775814                if (rc < 0) {
    776815                        continue;
    777816                }
    778817                rc = 0;
    779                 rc = dev_info->connection_func(path);
     818                rc = connect_keyboard_bypass(path);
    780819                if (rc > 0) {
    781820                        /* We do not allow unplug. */
    … …  
    792831/** Start a fibril monitoring hot-plugged keyboards.
    793832 */
    794 static void check_new_devices_in_background(int (*connection_func)(const char *),
    795     const char *classname)
    796 {
    797         struct hid_class_info *dev_info = malloc(sizeof(struct hid_class_info));
    798         if (dev_info == NULL) {
    799                 printf(NAME ": " \
    800                     "out of memory, will not start hot-plug-watch fibril.\n");
    801                 return;
    802         }
    803         int rc;
    804 
    805         rc = asprintf(&dev_info->classname, "%s", classname);
    806         if (rc < 0) {
    807                 printf(NAME ": failed to format classname: %s.\n",
    808                     str_error(rc));
    809                 return;
    810         }
    811         dev_info->connection_func = connection_func;
    812 
    813         fid_t fid = fibril_create(check_new_device_fibril, (void *)dev_info);
     833static void check_new_keyboards_in_background()
     834{
     835        fid_t fid = fibril_create(check_new_keyboards, (void *)"keyboard");
    814836        if (!fid) {
    815                 printf(NAME
    816                     ": failed to create hot-plug-watch fibril for %s.\n",
    817                     classname);
     837                printf(NAME ": failed to create hot-plug-watch fibril.\n");
    818838                return;
    819839        }
    … …  
    829849        }
    830850
    831         mouse_phone = connect_mouse("/dev/hid_in/mouse");
     851        /* Connect to mouse device */
     852        mouse_phone = -1;
     853        int mouse_fd = open("/dev/hid_in/mouse", O_RDONLY);
     854       
     855        if (mouse_fd < 0) {
     856                printf(NAME ": Notice - failed opening %s\n", "/dev/hid_in/mouse");
     857                goto skip_mouse;
     858        }
     859       
     860        mouse_phone = fd_phone(mouse_fd);
    832861        if (mouse_phone < 0) {
    833                 printf(NAME ": Failed to connect to mouse device: %s.\n",
    834                     str_error(mouse_phone));
    835         }
     862                printf(NAME ": Failed to connect to mouse device\n");
     863                goto skip_mouse;
     864        }
     865       
     866        if (async_connect_to_me(mouse_phone, SERVICE_CONSOLE, 0, 0, mouse_events)
     867            != 0) {
     868                printf(NAME ": Failed to create callback from mouse device\n");
     869                mouse_phone = -1;
     870                goto skip_mouse;
     871        }
     872       
     873skip_mouse:
    836874       
    837875        /* Connect to framebuffer driver */
    … …  
    917955       
    918956        /* Start fibril for checking on hot-plugged keyboards. */
    919         check_new_devices_in_background(connect_keyboard, "keyboard");
    920         check_new_devices_in_background(connect_mouse, "mouse");
     957        check_new_keyboards_in_background();
    921958
    922959        return true;
Note: See TracChangeset for help on using the changeset viewer.