Changeset cd1e6b62 in mainline
- Timestamp:
- 2011-03-28T15:45:46Z (14 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- e353e85
- Parents:
- d70765d (diff), 51e5608 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)
links above to see all the changes relative to each parent. - Files:
-
- 3 deleted
- 33 edited
Legend:
- Unmodified
- Added
- Removed
-
HelenOS.config
rd70765d rcd1e6b62 417 417 ! [(CONFIG_HID_IN=generic|CONFIG_HID_IN=keyboard)&PLATFORM=ia64&MACHINE=i460GX] CONFIG_PC_KBD (y/n) 418 418 419 % PC keyboard support 420 ! [(CONFIG_HID_IN=generic|CONFIG_HID_IN=keyboard)&PLATFORM=arm32&MACHINE=integratorcp] CONFIG_PC_KBD (y/n) 421 419 422 % Support for msim/GXemul keyboard 420 423 ! [CONFIG_HID_IN=generic&PLATFORM=mips32] CONFIG_MIPS_KBD (y/n) -
kernel/arch/arm32/src/mach/integratorcp/integratorcp.c
rd70765d rcd1e6b62 292 292 .y = 480, 293 293 .scan = 2560, 294 .visual = VISUAL_ BGR_0_8_8_8,294 .visual = VISUAL_RGB_8_8_8_0, 295 295 }; 296 296 -
kernel/arch/mips32/include/cp0.h
rd70765d rcd1e6b62 70 70 { \ 71 71 uint32_t retval; \ 72 asm ("mfc0 %0, $" #reg : "=r"(retval)); \72 asm volatile ("mfc0 %0, $" #reg : "=r"(retval)); \ 73 73 return retval; \ 74 74 } … … 76 76 #define GEN_WRITE_CP0(nm,reg) static inline void cp0_ ##nm##_write(uint32_t val) \ 77 77 { \ 78 asm ("mtc0 %0, $" #reg : : "r"(val) ); \78 asm volatile ("mtc0 %0, $" #reg : : "r"(val) ); \ 79 79 } 80 80 -
kernel/arch/sparc64/src/smp/sun4v/smp.c
rd70765d rcd1e6b62 1 1 /* 2 2 * Copyright (c) 2006 Jakub Jermar 3 * Copyright (c) 2009 Pavel Rimsky 3 * Copyright (c) 2009 Pavel Rimsky 4 4 * All rights reserved. 5 5 * … … 439 439 if (waitq_sleep_timeout(&ap_completion_wq, 10000000, SYNCH_FLAGS_NONE) == 440 440 ESYNCH_TIMEOUT) 441 printf("%s: waiting for processor (cpuid = %" PRIu 32") timed out\n",441 printf("%s: waiting for processor (cpuid = %" PRIu64 ") timed out\n", 442 442 __func__, cpuid); 443 443 -
kernel/arch/sparc64/src/sun4v/start.S
rd70765d rcd1e6b62 296 296 * Create the first stack frame. 297 297 */ 298 save %sp, -(STACK_WIND WO_SAVE_AREA_SIZE + STACK_ARG_SAVE_AREA_SIZE), %sp298 save %sp, -(STACK_WINDOW_SAVE_AREA_SIZE + STACK_ARG_SAVE_AREA_SIZE), %sp 299 299 flushw 300 300 add %g0, -STACK_BIAS, %fp -
kernel/arch/sparc64/src/trap/sun4v/interrupt.c
rd70765d rcd1e6b62 111 111 ((void (*)(void)) data1)(); 112 112 } else { 113 printf("Spurious interrupt on % d, data = %" PRIx64 ".\n",113 printf("Spurious interrupt on %" PRIu64 ", data = %" PRIx64 ".\n", 114 114 CPU->arch.id, data1); 115 115 } -
kernel/genarch/Makefile.inc
rd70765d rcd1e6b62 122 122 endif 123 123 124 ifeq ($(CONFIG_PL050),y)125 GENARCH_SOURCES += \126 genarch/src/kbrd/kbrd_pl050.c \127 genarch/src/kbrd/scanc_pl050.c128 endif129 130 124 ifeq ($(CONFIG_MAC_KBD),y) 131 125 GENARCH_SOURCES += \ -
kernel/generic/src/console/console.c
rd70765d rcd1e6b62 53 53 #include <str.h> 54 54 55 /* 56 * devman produces a lot of output and by giving so many pages 57 * we to allow /app/klog to catch-up. 58 */ 59 #ifdef CONFIG_DEVMAN_EARLY_LAUNCH 60 #define KLOG_PAGES 64 61 #else 55 62 #define KLOG_PAGES 4 63 #endif 64 56 65 #define KLOG_LENGTH (KLOG_PAGES * PAGE_SIZE / sizeof(wchar_t)) 57 66 #define KLOG_LATENCY 8 -
uspace/app/bdsh/cmds/modules/cat/cat.c
rd70765d rcd1e6b62 1 1 /* Copyright (c) 2008, Tim Post <tinkertim@gmail.com> 2 * Copyright (c) 2011, Martin Sucha 2 3 * All rights reserved. 3 4 * … … 35 36 #include <str.h> 36 37 #include <fcntl.h> 38 #include <io/console.h> 39 #include <io/color.h> 40 #include <io/style.h> 41 #include <io/keycode.h> 42 #include <errno.h> 43 #include <vfs/vfs.h> 44 #include <assert.h> 37 45 38 46 #include "config.h" … … 48 56 49 57 static const char *cat_oops = "That option is not yet supported\n"; 58 static const char *hexchars = "0123456789abcdef"; 59 60 static bool paging_enabled = false; 61 static size_t chars_remaining = 0; 62 static size_t lines_remaining = 0; 63 static sysarg_t console_cols = 0; 64 static sysarg_t console_rows = 0; 65 static bool should_quit = false; 50 66 51 67 static struct option const long_options[] = { … … 56 72 { "buffer", required_argument, 0, 'b' }, 57 73 { "more", no_argument, 0, 'm' }, 74 { "hex", no_argument, 0, 'x' }, 58 75 { 0, 0, 0, 0 } 59 76 }; … … 75 92 " -b, --buffer ## Set the read buffer size to ##\n" 76 93 " -m, --more Pause after each screen full\n" 94 " -x, --hex Print bytes as hex values\n" 77 95 "Currently, %s is under development, some options don't work.\n", 78 96 cmdname, cmdname); … … 82 100 } 83 101 84 static unsigned int cat_file(const char *fname, size_t blen) 102 static void waitprompt() 103 { 104 console_set_pos(fphone(stdout), 0, console_rows-1); 105 console_set_color(fphone(stdout), COLOR_BLUE, COLOR_WHITE, 0); 106 printf("ENTER/SPACE/PAGE DOWN - next page, " 107 "ESC/Q - quit, C - continue unpaged"); 108 fflush(stdout); 109 console_set_style(fphone(stdout), STYLE_NORMAL); 110 } 111 112 static void waitkey() 113 { 114 console_event_t ev; 115 116 while (true) { 117 if (!console_get_event(fphone(stdin), &ev)) { 118 return; 119 } 120 if (ev.type == KEY_PRESS) { 121 if (ev.key == KC_ESCAPE || ev.key == KC_Q) { 122 should_quit = true; 123 return; 124 } 125 if (ev.key == KC_C) { 126 paging_enabled = false; 127 return; 128 } 129 if (ev.key == KC_ENTER || ev.key == KC_SPACE || 130 ev.key == KC_PAGE_DOWN) { 131 return; 132 } 133 } 134 } 135 assert(false); 136 } 137 138 static void newpage() 139 { 140 console_clear(fphone(stdout)); 141 chars_remaining = console_cols; 142 lines_remaining = console_rows-1; 143 } 144 145 static void paged_char(wchar_t c) 146 { 147 putchar(c); 148 if (paging_enabled) { 149 chars_remaining--; 150 if (c == '\n' || chars_remaining == 0) { 151 chars_remaining = console_cols; 152 lines_remaining--; 153 } 154 if (lines_remaining == 0) { 155 fflush(stdout); 156 waitprompt(); 157 waitkey(); 158 newpage(); 159 } 160 } 161 } 162 163 static unsigned int cat_file(const char *fname, size_t blen, bool hex) 85 164 { 86 165 int fd, bytes = 0, count = 0, reads = 0; 87 166 off64_t total = 0; 88 167 char *buff = NULL; 168 int i; 169 size_t offset = 0; 89 170 90 171 fd = open(fname, O_RDONLY); … … 109 190 count += bytes; 110 191 buff[bytes] = '\0'; 111 printf("%s", buff); 192 offset = 0; 193 for (i = 0; i < bytes && !should_quit; i++) { 194 if (hex) { 195 paged_char(hexchars[((uint8_t)buff[i])/16]); 196 paged_char(hexchars[((uint8_t)buff[i])%16]); 197 } 198 else { 199 wchar_t c = str_decode(buff, &offset, bytes); 200 if (c == 0) { 201 // reached end of string 202 break; 203 } 204 paged_char(c); 205 } 206 207 } 112 208 reads++; 113 209 } 114 } while (bytes > 0 );210 } while (bytes > 0 && !should_quit); 115 211 116 212 close(fd); … … 131 227 unsigned int argc, i, ret = 0, buffer = 0; 132 228 int c, opt_ind; 229 bool hex = false; 230 bool more = false; 231 sysarg_t rows, cols; 232 int rc; 233 234 // reset global state 235 // TODO: move to structure? 236 paging_enabled = false; 237 chars_remaining = 0; 238 lines_remaining = 0; 239 console_cols = 0; 240 console_rows = 0; 241 should_quit = false; 133 242 134 243 argc = cli_count_args(argv); 135 244 136 245 for (c = 0, optind = 0, opt_ind = 0; c != -1;) { 137 c = getopt_long(argc, argv, " hvmH:t:b:", long_options, &opt_ind);246 c = getopt_long(argc, argv, "xhvmH:t:b:", long_options, &opt_ind); 138 247 switch (c) { 139 248 case 'h': … … 153 262 break; 154 263 case 'm': 155 printf("%s", cat_oops); 156 return CMD_FAILURE; 264 more = true; 265 break; 266 case 'x': 267 hex = true; 268 break; 157 269 } 158 270 } … … 168 280 if (buffer <= 0) 169 281 buffer = CAT_DEFAULT_BUFLEN; 170 171 for (i = optind; argv[i] != NULL; i++) 172 ret += cat_file(argv[i], buffer); 282 283 if (more) { 284 rc = console_get_size(fphone(stdout), &cols, &rows); 285 if (rc != EOK) { 286 printf("%s - cannot get console size\n", cmdname); 287 return CMD_FAILURE; 288 } 289 console_cols = cols; 290 console_rows = rows; 291 paging_enabled = true; 292 newpage(); 293 } 294 295 for (i = optind; argv[i] != NULL && !should_quit; i++) 296 ret += cat_file(argv[i], buffer, hex); 173 297 174 298 if (ret) -
uspace/app/bdsh/cmds/modules/cat/cat.h
rd70765d rcd1e6b62 4 4 /* Prototypes for the cat command, excluding entry points */ 5 5 6 static unsigned int cat_file(const char *, size_t );6 static unsigned int cat_file(const char *, size_t, bool); 7 7 8 8 #endif /* CAT_H */ -
uspace/app/bdsh/cmds/modules/cp/cp.c
rd70765d rcd1e6b62 108 108 for (;;) { 109 109 ssize_t res; 110 size_t written = 0; 110 111 111 112 bytes = read(fd1, buff, blen); … … 120 121 * returned less data than requested. 121 122 */ 122 bytes = write(fd2, buff , res);123 bytes = write(fd2, buff + written, res); 123 124 if (bytes < 0) 124 125 goto err; 126 written += bytes; 125 127 res -= bytes; 126 128 } while (res > 0); -
uspace/app/bdsh/cmds/modules/rm/rm.c
rd70765d rcd1e6b62 101 101 } 102 102 103 static unsigned int rm_recursive_not_empty_dirs(const char *path) 104 { 105 DIR *dirp; 106 struct dirent *dp; 107 char buff[PATH_MAX]; 108 unsigned int scope; 109 unsigned int ret = 0; 110 111 dirp = opendir(path); 112 if (!dirp) { 113 /* May have been deleted between scoping it and opening it */ 114 cli_error(CL_EFAIL, "Could not open %s", path); 115 return ret; 116 } 117 118 memset(buff, 0, sizeof(buff)); 119 while ((dp = readdir(dirp))) { 120 snprintf(buff, PATH_MAX - 1, "%s/%s", path, dp->d_name); 121 scope = rm_scope(buff); 122 switch (scope) { 123 case RM_BOGUS: 124 break; 125 case RM_FILE: 126 ret += rm_single(buff); 127 break; 128 case RM_DIR: 129 ret += rm_recursive(buff); 130 break; 131 } 132 } 133 134 return ret; 135 } 136 103 137 static unsigned int rm_recursive(const char *path) 104 138 { 105 139 int rc; 140 unsigned int ret = 0; 106 141 107 142 /* First see if it will just go away */ … … 111 146 112 147 /* Its not empty, recursively scan it */ 113 cli_error(CL_ENOTSUP, 114 "Can not remove %s, directory not empty", path); 115 return 1; 148 ret = rm_recursive_not_empty_dirs(path); 149 150 /* Delete directory */ 151 rc = rmdir(path); 152 if (rc == 0) 153 return ret; 154 155 cli_error(CL_ENOTSUP, "Can not remove %s", path); 156 157 return ret + 1; 116 158 } 117 159 -
uspace/app/init/init.c
rd70765d rcd1e6b62 288 288 289 289 spawn("/srv/clip"); 290 291 #ifdef CONFIG_DEVMAN_EARLY_LAUNCH292 spawn("/srv/devman");293 #endif294 290 295 291 /* … … 318 314 getterm("term/vc6", "/app/klog", false); 319 315 320 #ifndef CONFIG_DEVMAN_EARLY_LAUNCH 316 #ifdef CONFIG_DEVMAN_EARLY_LAUNCH 317 spawn("/srv/devman"); 318 #else 321 319 getterm("term/vc7", "/srv/devman", false); 322 320 #endif -
uspace/drv/ohci/root_hub.c
rd70765d rcd1e6b62 43 43 #include <usb/classes/hub.h> 44 44 45 /** 46 * standart device descriptor for ohci root hub 47 */ 45 48 static const usb_standard_device_descriptor_t ohci_rh_device_descriptor = 46 49 { … … 61 64 }; 62 65 66 /** 67 * standart configuration descriptor with filled common values 68 * for ohci root hubs 69 */ 63 70 static const usb_standard_configuration_descriptor_t ohci_rh_conf_descriptor = 64 71 { … … 73 80 }; 74 81 82 /** 83 * standart ohci root hub interface descriptor 84 */ 75 85 static const usb_standard_interface_descriptor_t ohci_rh_iface_descriptor = 76 86 { … … 87 97 }; 88 98 99 /** 100 * standart ohci root hub endpoint descriptor 101 */ 89 102 static const usb_standard_endpoint_descriptor_t ohci_rh_ep_descriptor = 90 103 { … … 117 130 /*----------------------------------------------------------------------------*/ 118 131 119 132 /** 133 * create answer to port status_request 134 * 135 * Copy content of corresponding port status register to answer buffer. 136 * 137 * @param instance root hub instance 138 * @param port port number, counted from 1 139 * @param request structure containing both request and response information 140 * @return error code 141 */ 120 142 static int process_get_port_status_request(rh_t *instance, uint16_t port, 121 143 usb_transfer_batch_t * request){ … … 128 150 } 129 151 152 /** 153 * create answer to port status_request 154 * 155 * Copy content of hub status register to answer buffer. 156 * 157 * @param instance root hub instance 158 * @param request structure containing both request and response information 159 * @return error code 160 */ 130 161 static int process_get_hub_status_request(rh_t *instance, 131 162 usb_transfer_batch_t * request){ … … 139 170 } 140 171 141 static void usb_create_serialized_hub_descriptor(rh_t *instance, uint8_t ** out_result, 172 /** 173 * Create hub descriptor used in hub-driver <-> hub communication 174 * 175 * This means creating byt array from data in root hub registers. For more 176 * info see usb hub specification. 177 * 178 * @param instance root hub instance 179 * @param@out out_result pointer to resultant serialized descriptor 180 * @param@out out_size size of serialized descriptor 181 */ 182 static void usb_create_serialized_hub_descriptor(rh_t *instance, 183 uint8_t ** out_result, 142 184 size_t * out_size) { 143 185 //base size … … 179 221 180 222 223 /** 224 * create answer to status request 225 * 226 * This might be either hub status or port status request. If neither, 227 * ENOTSUP is returned. 228 * @param instance root hub instance 229 * @param request structure containing both request and response information 230 * @return error code 231 */ 181 232 static int process_get_status_request(rh_t *instance, 182 233 usb_transfer_batch_t * request) … … 201 252 } 202 253 254 /** 255 * create answer to status interrupt consisting of change bitmap 256 * 257 * Result contains bitmap where bit 0 indicates change on hub and 258 * bit i indicates change on i`th port (i>0). For more info see 259 * Hub and Port status bitmap specification in USB specification. 260 * @param instance root hub instance 261 * @param@out buffer pointer to created interrupt mas 262 * @param@out buffer_size size of created interrupt mask 263 */ 203 264 static void create_interrupt_mask(rh_t *instance, void ** buffer, 204 265 size_t * buffer_size){ … … 224 285 } 225 286 226 287 /** 288 * create standart configuration descriptor for the root hub instance 289 * @param instance root hub instance 290 * @return newly allocated descriptor 291 */ 292 static usb_standard_configuration_descriptor_t * 293 usb_ohci_rh_create_standart_configuration_descriptor(rh_t *instance){ 294 usb_standard_configuration_descriptor_t * descriptor = 295 malloc(sizeof(usb_standard_configuration_descriptor_t)); 296 memcpy(descriptor, &ohci_rh_conf_descriptor, 297 sizeof(usb_standard_configuration_descriptor_t)); 298 /// \TODO should this include device descriptor? 299 const size_t hub_descriptor_size = 7 + 300 2* (instance->port_count / 8 + 301 ((instance->port_count % 8 > 0) ? 1 : 0)); 302 descriptor->total_length = 303 sizeof(usb_standard_configuration_descriptor_t)+ 304 sizeof(usb_standard_endpoint_descriptor_t)+ 305 sizeof(usb_standard_interface_descriptor_t)+ 306 hub_descriptor_size; 307 return descriptor; 308 } 309 310 /** 311 * create answer to a descriptor request 312 * 313 * This might be a request for standard (configuration, device, endpoint or 314 * interface) or device specific (hub) descriptor. 315 * @param instance root hub instance 316 * @param request structure containing both request and response information 317 * @return error code 318 */ 227 319 static int process_get_descriptor_request(rh_t *instance, 228 320 usb_transfer_batch_t *request){ 229 /// \TODO230 321 usb_device_request_setup_packet_t * setup_request = 231 322 (usb_device_request_setup_packet_t*)request->setup_buffer; 232 323 size_t size; 233 const void * result_descriptor ;324 const void * result_descriptor = NULL; 234 325 const uint16_t setup_request_value = setup_request->value_high; 235 326 //(setup_request->value_low << 8); 236 327 bool del = false; 237 238 328 switch (setup_request_value) 239 329 { 240 case USB_DESCTYPE_HUB: { 241 uint8_t * descriptor; 242 usb_create_serialized_hub_descriptor( 243 instance, &descriptor, &size); 244 result_descriptor = descriptor; 245 break; 246 } 247 case USB_DESCTYPE_DEVICE: { 248 usb_log_debug("USB_DESCTYPE_DEVICE\n"); 249 result_descriptor = &ohci_rh_device_descriptor; 250 size = sizeof(ohci_rh_device_descriptor); 251 break; 252 } 253 case USB_DESCTYPE_CONFIGURATION: { 254 usb_log_debug("USB_DESCTYPE_CONFIGURATION\n"); 255 usb_standard_configuration_descriptor_t * descriptor = 256 malloc(sizeof(usb_standard_configuration_descriptor_t)); 257 memcpy(descriptor, &ohci_rh_conf_descriptor, 258 sizeof(usb_standard_configuration_descriptor_t)); 259 /// \TODO should this include device descriptor? 260 const size_t hub_descriptor_size = 7 + 261 2* (instance->port_count / 8 + 262 ((instance->port_count % 8 > 0) ? 1 : 0)); 263 descriptor->total_length = 264 sizeof(usb_standard_configuration_descriptor_t)+ 265 sizeof(usb_standard_endpoint_descriptor_t)+ 266 sizeof(usb_standard_interface_descriptor_t)+ 267 hub_descriptor_size; 268 result_descriptor = descriptor; 269 size = sizeof(usb_standard_configuration_descriptor_t); 270 del = true; 271 break; 272 } 273 case USB_DESCTYPE_INTERFACE: { 274 usb_log_debug("USB_DESCTYPE_INTERFACE\n"); 275 result_descriptor = &ohci_rh_iface_descriptor; 276 size = sizeof(ohci_rh_iface_descriptor); 277 break; 278 } 279 case USB_DESCTYPE_ENDPOINT: { 280 usb_log_debug("USB_DESCTYPE_ENDPOINT\n"); 281 result_descriptor = &ohci_rh_ep_descriptor; 282 size = sizeof(ohci_rh_ep_descriptor); 283 break; 284 } 285 default: { 286 usb_log_debug("USB_DESCTYPE_EINVAL %d \n",setup_request->value); 287 usb_log_debug("\ttype %d\n\trequest %d\n\tvalue %d\n\tindex %d\n\tlen %d\n ", 288 setup_request->request_type, 289 setup_request->request, 290 setup_request_value, 291 setup_request->index, 292 setup_request->length 293 ); 294 return EINVAL; 295 } 296 } 297 #if 0 298 if(setup_request_value == USB_DESCTYPE_HUB){ 299 usb_log_debug("USB_DESCTYPE_HUB\n"); 300 //create hub descriptor 301 uint8_t * descriptor; 302 usb_create_serialized_hub_descriptor(instance, 303 &descriptor, &size); 304 result_descriptor = descriptor; 305 }else if(setup_request_value == USB_DESCTYPE_DEVICE){ 306 //create std device descriptor 307 usb_log_debug("USB_DESCTYPE_DEVICE\n"); 308 usb_standard_device_descriptor_t * descriptor = 309 (usb_standard_device_descriptor_t*) 310 malloc(sizeof(usb_standard_device_descriptor_t)); 311 descriptor->configuration_count = 1; 312 descriptor->descriptor_type = USB_DESCTYPE_DEVICE; 313 descriptor->device_class = USB_CLASS_HUB; 314 descriptor->device_protocol = 0; 315 descriptor->device_subclass = 0; 316 descriptor->device_version = 0; 317 descriptor->length = sizeof(usb_standard_device_descriptor_t); 318 /// \TODO this value is guessed 319 descriptor->max_packet_size = 8; 320 descriptor->product_id = 0x0001; 321 /// \TODO these values migt be different 322 descriptor->str_serial_number = 0; 323 descriptor->str_serial_number = 0; 324 descriptor->usb_spec_version = 0; 325 descriptor->vendor_id = 0x16db; 326 result_descriptor = descriptor; 327 size = sizeof(usb_standard_device_descriptor_t); 328 }else if(setup_request_value == USB_DESCTYPE_CONFIGURATION){ 329 usb_log_debug("USB_DESCTYPE_CONFIGURATION\n"); 330 usb_standard_configuration_descriptor_t * descriptor = 331 (usb_standard_configuration_descriptor_t*) 332 malloc(sizeof(usb_standard_configuration_descriptor_t)); 333 /// \TODO some values are default or guessed 334 descriptor->attributes = 1<<7; 335 descriptor->configuration_number = 1; 336 descriptor->descriptor_type = USB_DESCTYPE_CONFIGURATION; 337 descriptor->interface_count = 1; 338 descriptor->length = sizeof(usb_standard_configuration_descriptor_t); 339 descriptor->max_power = 100; 340 descriptor->str_configuration = 0; 341 /// \TODO should this include device descriptor? 342 size_t hub_descriptor_size = 7 + 343 2* (instance->port_count / 8 + 344 ((instance->port_count % 8 > 0) ? 1 : 0)); 345 descriptor->total_length = 346 sizeof(usb_standard_configuration_descriptor_t)+ 347 sizeof(usb_standard_endpoint_descriptor_t)+ 348 sizeof(usb_standard_interface_descriptor_t)+ 349 hub_descriptor_size; 350 result_descriptor = descriptor; 351 size = sizeof(usb_standard_configuration_descriptor_t); 352 353 }else if(setup_request_value == USB_DESCTYPE_INTERFACE){ 354 usb_log_debug("USB_DESCTYPE_INTERFACE\n"); 355 usb_standard_interface_descriptor_t * descriptor = 356 (usb_standard_interface_descriptor_t*) 357 malloc(sizeof(usb_standard_interface_descriptor_t)); 358 descriptor->alternate_setting = 0; 359 descriptor->descriptor_type = USB_DESCTYPE_INTERFACE; 360 descriptor->endpoint_count = 1; 361 descriptor->interface_class = USB_CLASS_HUB; 362 /// \TODO is this correct? 363 descriptor->interface_number = 1; 364 descriptor->interface_protocol = 0; 365 descriptor->interface_subclass = 0; 366 descriptor->length = sizeof(usb_standard_interface_descriptor_t); 367 descriptor->str_interface = 0; 368 result_descriptor = descriptor; 369 size = sizeof(usb_standard_interface_descriptor_t); 370 }else if(setup_request_value == USB_DESCTYPE_ENDPOINT){ 371 usb_log_debug("USB_DESCTYPE_ENDPOINT\n"); 372 usb_standard_endpoint_descriptor_t * descriptor = 373 (usb_standard_endpoint_descriptor_t*) 374 malloc(sizeof(usb_standard_endpoint_descriptor_t)); 375 descriptor->attributes = USB_TRANSFER_INTERRUPT; 376 descriptor->descriptor_type = USB_DESCTYPE_ENDPOINT; 377 descriptor->endpoint_address = 1 + (1<<7); 378 descriptor->length = sizeof(usb_standard_endpoint_descriptor_t); 379 descriptor->max_packet_size = 8; 380 descriptor->poll_interval = 255; 381 result_descriptor = descriptor; 382 size = sizeof(usb_standard_endpoint_descriptor_t); 383 }else{ 384 usb_log_debug("USB_DESCTYPE_EINVAL %d \n",setup_request->value); 385 usb_log_debug("\ttype %d\n\trequest %d\n\tvalue %d\n\tindex %d\n\tlen %d\n ", 386 setup_request->request_type, 387 setup_request->request, 388 setup_request_value, 389 setup_request->index, 390 setup_request->length 391 ); 392 return EINVAL; 393 } 394 #endif 330 case USB_DESCTYPE_HUB: { 331 uint8_t * descriptor; 332 usb_create_serialized_hub_descriptor( 333 instance, &descriptor, &size); 334 result_descriptor = descriptor; 335 if(result_descriptor) del = true; 336 break; 337 } 338 case USB_DESCTYPE_DEVICE: { 339 usb_log_debug("USB_DESCTYPE_DEVICE\n"); 340 result_descriptor = &ohci_rh_device_descriptor; 341 size = sizeof(ohci_rh_device_descriptor); 342 break; 343 } 344 case USB_DESCTYPE_CONFIGURATION: { 345 usb_log_debug("USB_DESCTYPE_CONFIGURATION\n"); 346 usb_standard_configuration_descriptor_t * descriptor = 347 usb_ohci_rh_create_standart_configuration_descriptor( 348 instance); 349 result_descriptor = descriptor; 350 size = sizeof(usb_standard_configuration_descriptor_t); 351 del = true; 352 break; 353 } 354 case USB_DESCTYPE_INTERFACE: { 355 usb_log_debug("USB_DESCTYPE_INTERFACE\n"); 356 result_descriptor = &ohci_rh_iface_descriptor; 357 size = sizeof(ohci_rh_iface_descriptor); 358 break; 359 } 360 case USB_DESCTYPE_ENDPOINT: { 361 usb_log_debug("USB_DESCTYPE_ENDPOINT\n"); 362 result_descriptor = &ohci_rh_ep_descriptor; 363 size = sizeof(ohci_rh_ep_descriptor); 364 break; 365 } 366 default: { 367 usb_log_debug("USB_DESCTYPE_EINVAL %d \n",setup_request->value); 368 usb_log_debug("\ttype %d\n\trequest %d\n\tvalue %d\n\tindex %d\n\tlen %d\n ", 369 setup_request->request_type, 370 setup_request->request, 371 setup_request_value, 372 setup_request->index, 373 setup_request->length 374 ); 375 return EINVAL; 376 } 377 } 395 378 if(request->buffer_size < size){ 396 379 size = request->buffer_size; … … 403 386 } 404 387 388 /** 389 * answer to get configuration request 390 * 391 * Root hub works independently on the configuration. 392 * @param instance root hub instance 393 * @param request structure containing both request and response information 394 * @return error code 395 */ 405 396 static int process_get_configuration_request(rh_t *instance, 406 397 usb_transfer_batch_t *request){ … … 414 405 } 415 406 407 /** 408 * process feature-enabling/disabling request on hub 409 * 410 * @param instance root hub instance 411 * @param feature feature selector 412 * @param enable enable or disable specified feature 413 * @return error code 414 */ 416 415 static int process_hub_feature_set_request(rh_t *instance, 417 416 uint16_t feature, bool enable){ … … 427 426 } 428 427 428 /** 429 * process feature-enabling/disabling request on hub 430 * 431 * @param instance root hub instance 432 * @param feature feature selector 433 * @param port port number, counted from 1 434 * @param enable enable or disable the specified feature 435 * @return error code 436 */ 429 437 static int process_port_feature_set_request(rh_t *instance, 430 438 uint16_t feature, uint16_t port, bool enable){ … … 442 450 } 443 451 452 /** 453 * register address to this device 454 * 455 * @param instance root hub instance 456 * @param address new address 457 * @return error code 458 */ 444 459 static int process_address_set_request(rh_t *instance, 445 460 uint16_t address){ … … 448 463 } 449 464 465 /** 466 * process one of requests that requere output data 467 * 468 * Request can be one of USB_DEVREQ_GET_STATUS, USB_DEVREQ_GET_DESCRIPTOR or 469 * USB_DEVREQ_GET_CONFIGURATION. 470 * @param instance root hub instance 471 * @param request structure containing both request and response information 472 * @return error code 473 */ 450 474 static int process_request_with_output(rh_t *instance, 451 475 usb_transfer_batch_t *request){ … … 467 491 } 468 492 493 /** 494 * process one of requests that carry input data 495 * 496 * Request can be one of USB_DEVREQ_SET_DESCRIPTOR or 497 * USB_DEVREQ_SET_CONFIGURATION. 498 * @param instance root hub instance 499 * @param request structure containing both request and response information 500 * @return error code 501 */ 469 502 static int process_request_with_input(rh_t *instance, 470 503 usb_transfer_batch_t *request){ … … 483 516 } 484 517 485 518 /** 519 * process one of requests that do not request nor carry additional data 520 * 521 * Request can be one of USB_DEVREQ_CLEAR_FEATURE, USB_DEVREQ_SET_FEATURE or 522 * USB_DEVREQ_SET_ADDRESS. 523 * @param instance root hub instance 524 * @param request structure containing both request and response information 525 * @return error code 526 */ 486 527 static int process_request_without_data(rh_t *instance, 487 528 usb_transfer_batch_t *request){ … … 513 554 } 514 555 515 516 /** 517 * 518 * @param instance 519 * @param request 520 * @return 556 /** 557 * process hub control request 558 * 559 * If needed, writes answer into the request structure. 560 * Request can be one of 561 * USB_DEVREQ_GET_STATUS, 562 * USB_DEVREQ_GET_DESCRIPTOR, 563 * USB_DEVREQ_GET_CONFIGURATION, 564 * USB_DEVREQ_CLEAR_FEATURE, 565 * USB_DEVREQ_SET_FEATURE, 566 * USB_DEVREQ_SET_ADDRESS, 567 * USB_DEVREQ_SET_DESCRIPTOR or 568 * USB_DEVREQ_SET_CONFIGURATION. 569 * 570 * @param instance root hub instance 571 * @param request structure containing both request and response information 572 * @return error code 573 */ 574 static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request){ 575 int opResult; 576 if (request->setup_buffer) { 577 if(sizeof(usb_device_request_setup_packet_t)>request->setup_size){ 578 usb_log_error("setup packet too small\n"); 579 return EINVAL; 580 } 581 usb_log_info("CTRL packet: %s.\n", 582 usb_debug_str_buffer((const uint8_t *)request->setup_buffer, 8, 8)); 583 usb_device_request_setup_packet_t * setup_request = 584 (usb_device_request_setup_packet_t*)request->setup_buffer; 585 if( 586 setup_request->request == USB_DEVREQ_GET_STATUS 587 || setup_request->request == USB_DEVREQ_GET_DESCRIPTOR 588 || setup_request->request == USB_DEVREQ_GET_CONFIGURATION 589 ){ 590 usb_log_debug("processing request with output\n"); 591 opResult = process_request_with_output(instance,request); 592 }else if( 593 setup_request->request == USB_DEVREQ_CLEAR_FEATURE 594 || setup_request->request == USB_DEVREQ_SET_FEATURE 595 || setup_request->request == USB_DEVREQ_SET_ADDRESS 596 ){ 597 usb_log_debug("processing request without additional data\n"); 598 opResult = process_request_without_data(instance,request); 599 }else if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR 600 || setup_request->request == USB_DEVREQ_SET_CONFIGURATION 601 ){ 602 usb_log_debug("processing request with input\n"); 603 opResult = process_request_with_input(instance,request); 604 }else{ 605 usb_log_warning("received unsuported request: %d\n", 606 setup_request->request 607 ); 608 opResult = ENOTSUP; 609 } 610 }else{ 611 usb_log_error("root hub received empty transaction?"); 612 opResult = EINVAL; 613 } 614 return opResult; 615 } 616 617 /** 618 * process root hub request 619 * 620 * @param instance root hub instance 621 * @param request structure containing both request and response information 622 * @return error code 521 623 */ 522 624 int rh_request(rh_t *instance, usb_transfer_batch_t *request) … … 526 628 int opResult; 527 629 if(request->transfer_type == USB_TRANSFER_CONTROL){ 528 if (request->setup_buffer) { 529 usb_log_info("Root hub got CTRL packet: %s.\n", 530 usb_debug_str_buffer((const uint8_t *)request->setup_buffer, 8, 8)); 531 if(sizeof(usb_device_request_setup_packet_t)>request->setup_size){ 532 usb_log_error("setup packet too small\n"); 533 return EINVAL; 534 } 535 usb_device_request_setup_packet_t * setup_request = 536 (usb_device_request_setup_packet_t*)request->setup_buffer; 537 if( 538 setup_request->request == USB_DEVREQ_GET_STATUS 539 || setup_request->request == USB_DEVREQ_GET_DESCRIPTOR 540 || setup_request->request == USB_DEVREQ_GET_CONFIGURATION 541 ){ 542 usb_log_debug("processing request with output\n"); 543 opResult = process_request_with_output(instance,request); 544 }else if( 545 setup_request->request == USB_DEVREQ_CLEAR_FEATURE 546 || setup_request->request == USB_DEVREQ_SET_FEATURE 547 || setup_request->request == USB_DEVREQ_SET_ADDRESS 548 ){ 549 usb_log_debug("processing request without additional data\n"); 550 opResult = process_request_without_data(instance,request); 551 }else if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR 552 || setup_request->request == USB_DEVREQ_SET_CONFIGURATION 553 ){ 554 usb_log_debug("processing request with input\n"); 555 opResult = process_request_with_input(instance,request); 556 }else{ 557 usb_log_warning("received unsuported request: %d\n", 558 setup_request->request 559 ); 560 opResult = ENOTSUP; 561 } 562 }else{ 563 usb_log_error("root hub received empty transaction?"); 564 opResult = EINVAL; 565 } 630 usb_log_info("Root hub got CONTROL packet\n"); 631 opResult = process_ctrl_request(instance,request); 566 632 }else if(request->transfer_type == USB_TRANSFER_INTERRUPT){ 567 633 usb_log_info("Root hub got INTERRUPT packet\n"); … … 582 648 void rh_interrupt(rh_t *instance) 583 649 { 584 usb_log_ error("Root hub interrupt not implemented.\n");585 /* TODO: implement */650 usb_log_info("Whoa whoa wait, I`m not supposed to receive any interrupts, am I?\n"); 651 /* TODO: implement? */ 586 652 } 587 653 /** -
uspace/drv/ohci/root_hub.h
rd70765d rcd1e6b62 41 41 #include "batch.h" 42 42 43 /** 44 * ohci root hub representation 45 */ 43 46 typedef struct rh { 47 /** pointer to ohci driver registers */ 44 48 ohci_regs_t *registers; 49 /** usb address of the root hub */ 45 50 usb_address_t address; 51 /** ddf device information */ 46 52 ddf_dev_t *device; 53 /** hub port count */ 47 54 int port_count; 48 55 } rh_t; -
uspace/drv/pciintel/pci.c
rd70765d rcd1e6b62 95 95 sysarg_t i8259; 96 96 97 int irc_phone = -1; 98 int irc_service = -1; 99 100 if ((sysinfo_get_value("apic", &apic) == EOK) && (apic)) { 101 irc_service = SERVICE_APIC; 102 } else if ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259)) { 103 irc_service = SERVICE_I8259; 104 } 105 106 if (irc_service == -1) { 107 return false; 108 } 109 110 irc_phone = service_connect_blocking(irc_service, 0, 0); 97 int irc_phone = ENOTSUP; 98 99 if (((sysinfo_get_value("apic", &apic) == EOK) && (apic)) 100 || ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259))) { 101 irc_phone = service_connect_blocking(SERVICE_IRC, 0, 0); 102 } 103 111 104 if (irc_phone < 0) { 112 105 return false; -
uspace/drv/usbhub/port_status.h
rd70765d rcd1e6b62 79 79 80 80 /** 81 * set the device request to be a port feature enable request 82 * @param request 83 * @param port 84 * @param feature_selector 85 */ 86 static inline void usb_hub_set_enable_port_feature_request( 87 usb_device_request_setup_packet_t * request, uint16_t port, 88 uint16_t feature_selector 89 ){ 90 request->index = port; 91 request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE; 92 request->request = USB_HUB_REQUEST_SET_FEATURE; 93 request->value = feature_selector; 94 request->length = 0; 95 } 96 97 98 /** 81 99 * set the device request to be a port enable request 82 100 * @param request … … 191 209 request->length = 0; 192 210 } 211 193 212 194 213 /** get i`th bit of port status */ -
uspace/drv/usbhub/usbhub.c
rd70765d rcd1e6b62 53 53 #include "usb/classes/classes.h" 54 54 55 56 static void usb_hub_init_add_device(usb_hub_info_t * hub, uint16_t port, 57 usb_speed_t speed); 58 59 static int usb_hub_trigger_connecting_non_removable_devices( 60 usb_hub_info_t * hub, usb_hub_descriptor_t * descriptor); 61 62 /** 63 * control loop running in hub`s fibril 64 * 65 * Hub`s fibril periodically asks for changes on hub and if needded calls 66 * change handling routine. 67 * @warning currently hub driver asks for changes once a second 68 * @param hub_info_param hub representation pointer 69 * @return zero 70 */ 55 71 int usb_hub_control_loop(void * hub_info_param){ 56 72 usb_hub_info_t * hub_info = (usb_hub_info_t*)hub_info_param; … … 91 107 92 108 /** 93 * Load hub-specific information into hub_info structure .109 * Load hub-specific information into hub_info structure and process if needed 94 110 * 95 111 * Particularly read port count and initialize structure holding port 96 * information. 112 * information. If there are non-removable devices, start initializing them. 97 113 * This function is hub-specific and should be run only after the hub is 98 114 * configured using usb_hub_set_configuration function. 99 * @param hub_info pointer to structure with usb hub data115 * @param hub_info hub representation 100 116 * @return error code 101 117 */ 102 static int usb_hub_ get_hub_specific_info(usb_hub_info_t * hub_info){118 static int usb_hub_process_hub_specific_info(usb_hub_info_t * hub_info){ 103 119 // get hub descriptor 104 120 usb_log_debug("creating serialized descriptor\n"); … … 107 123 108 124 /* this was one fix of some bug, should not be needed anymore 125 * these lines allow to reset hub once more, it can be used as 126 * brute-force initialization for non-removable devices 109 127 int opResult = usb_request_set_configuration(&result->endpoints.control, 1); 110 128 if(opResult!=EOK){ … … 141 159 hub_info->attached_devs[i].address=0; 142 160 } 161 //handle non-removable devices 162 usb_hub_trigger_connecting_non_removable_devices(hub_info, descriptor); 143 163 usb_log_debug2("freeing data\n"); 144 164 free(serialized_descriptor); … … 152 172 * Check whether there is at least one configuration and sets the first one. 153 173 * This function should be run prior to running any hub-specific action. 154 * @param hub_info 155 * @return 174 * @param hub_info hub representation 175 * @return error code 156 176 */ 157 177 static int usb_hub_set_configuration(usb_hub_info_t * hub_info){ … … 218 238 } 219 239 //get port count and create attached_devs 220 opResult = usb_hub_ get_hub_specific_info(hub_info);240 opResult = usb_hub_process_hub_specific_info(hub_info); 221 241 if(opResult!=EOK){ 222 242 usb_log_error("could not set hub configuration, errno %d\n",opResult); … … 256 276 //********************************************* 257 277 // 258 // hub driver code, main loop 278 // hub driver code, main loop and port handling 259 279 // 260 280 //********************************************* 281 282 /** 283 * triggers actions to connect non0removable devices 284 * 285 * This will trigger operations leading to activated non-removable device. 286 * Control pipe of the hub must be open fo communication. 287 * @param hub hub representation 288 * @param descriptor usb hub descriptor 289 * @return error code 290 */ 291 static int usb_hub_trigger_connecting_non_removable_devices(usb_hub_info_t * hub, 292 usb_hub_descriptor_t * descriptor) 293 { 294 usb_log_info("attaching non-removable devices(if any)\n"); 295 usb_device_request_setup_packet_t request; 296 int opResult; 297 size_t rcvd_size; 298 usb_port_status_t status; 299 uint8_t * non_removable_dev_bitmap = descriptor->devices_removable; 300 int port; 301 for(port=1;port<=descriptor->ports_count;++port){ 302 bool is_non_removable = 303 ((non_removable_dev_bitmap[port/8]) >> (port%8)) %2; 304 if(is_non_removable){ 305 usb_log_debug("non-removable device on port %d\n",port); 306 usb_hub_set_port_status_request(&request, port); 307 opResult = usb_pipe_control_read( 308 hub->control_pipe, 309 &request, sizeof(usb_device_request_setup_packet_t), 310 &status, 4, &rcvd_size 311 ); 312 if (opResult != EOK) { 313 usb_log_error("could not get port status of port %d errno:%d\n", 314 port, opResult); 315 return opResult; 316 } 317 //set the status change bit, so it will be noticed in driver loop 318 if(usb_port_dev_connected(&status)){ 319 usb_hub_set_enable_port_feature_request(&request, port, 320 USB_HUB_FEATURE_C_PORT_CONNECTION); 321 opResult = usb_pipe_control_read( 322 hub->control_pipe, 323 &request, sizeof(usb_device_request_setup_packet_t), 324 &status, 4, &rcvd_size 325 ); 326 if (opResult != EOK) { 327 usb_log_warning( 328 "could not set port change on port %d errno:%d\n", 329 port, opResult); 330 } 331 } 332 } 333 } 334 return EOK; 335 } 336 261 337 262 338 /** … … 280 356 /** 281 357 * Reset the port with new device and reserve the default address. 282 * @param h c283 * @param port 284 * @param target358 * @param hub hub representation 359 * @param port port number, starting from 1 360 * @param speed transfer speed of attached device, one of low, full or high 285 361 */ 286 362 static void usb_hub_init_add_device(usb_hub_info_t * hub, uint16_t port, … … 315 391 if (opResult != EOK) { 316 392 usb_log_error("something went wrong when reseting a port %d\n",opResult); 317 //usb_hub_release_default_address(hc);318 393 usb_hub_release_default_address(hub); 319 394 } … … 323 398 /** 324 399 * Finalize adding new device after port reset 325 * @param hc 326 * @param port 327 * @param target 400 * 401 * Set device`s address and start it`s driver. 402 * @param hub hub representation 403 * @param port port number, starting from 1 404 * @param speed transfer speed of attached device, one of low, full or high 328 405 */ 329 406 static void usb_hub_finalize_add_device( usb_hub_info_t * hub, … … 375 452 } 376 453 377 378 454 //opResult = usb_hub_release_default_address(hc); 379 455 opResult = usb_hub_release_default_address(hub); … … 410 486 411 487 /** 412 * Unregister device address in hc 413 * @param hc 414 * @param port 415 * @param target 488 * routine called when a device on port has been removed 489 * 490 * If the device on port had default address, it releases default address. 491 * Otherwise does not do anything, because DDF does not allow to remove device 492 * from it`s device tree. 493 * @param hub hub representation 494 * @param port port number, starting from 1 416 495 */ 417 496 static void usb_hub_removed_device( … … 452 531 * Turn off the power on the port. 453 532 * 454 * @param hub 455 * @param port 533 * @param hub hub representation 534 * @param port port number, starting from 1 456 535 */ 457 536 static void usb_hub_over_current( usb_hub_info_t * hub, … … 468 547 /** 469 548 * Process interrupts on given hub port 470 * @param hc 471 * @param port 472 * @param target 549 * 550 * Accepts connection, over current and port reset change. 551 * @param hub hub representation 552 * @param port port number, starting from 1 473 553 */ 474 554 static void usb_hub_process_interrupt(usb_hub_info_t * hub, … … 541 621 542 622 /** 543 * Check changes on particular hub 544 * @param hub_info_param pointer to usb_hub_info_t structure 545 * @return error code if there is problem when initializing communication with 546 * hub, EOK otherwise 623 * check changes on hub 624 * 625 * Handles changes on each port with a status change. 626 * @param hub_info hub representation 627 * @return error code 547 628 */ 548 629 int usb_hub_check_hub_changes(usb_hub_info_t * hub_info){ -
uspace/lib/c/include/ipc/services.h
rd70765d rcd1e6b62 47 47 SERVICE_DEVMAP, 48 48 SERVICE_DEVMAN, 49 SERVICE_FHC, 50 SERVICE_OBIO, 51 SERVICE_APIC, 52 SERVICE_I8259, 49 SERVICE_IRC, 53 50 SERVICE_CLIPBOARD, 54 51 SERVICE_NETWORKING, -
uspace/lib/fs/libfs.c
rd70765d rcd1e6b62 391 391 if (lflag & L_CREATE) 392 392 (void) ops->destroy(fn); 393 else 394 (void) ops->node_put(fn); 393 395 async_answer_0(rid, rc); 394 396 } else { … … 473 475 if (lflag & L_CREATE) 474 476 (void) ops->destroy(fn); 477 else 478 (void) ops->node_put(fn); 475 479 async_answer_0(rid, rc); 476 480 } else { -
uspace/srv/hid/kbd/Makefile
rd70765d rcd1e6b62 78 78 SOURCES += \ 79 79 port/pl050.c \ 80 ctl/p l050.c80 ctl/pc.c 81 81 endif 82 82 endif -
uspace/srv/hid/kbd/generic/kbd.c
rd70765d rcd1e6b62 67 67 static unsigned lock_keys; 68 68 69 int cir_service = 0;70 int cir_phone = -1;69 bool irc_service = false; 70 int irc_phone = -1; 71 71 72 72 #define NUM_LAYOUTS 3 … … 216 216 sysarg_t obio; 217 217 218 if ((sysinfo_get_value("kbd.cir.fhc", &fhc) == EOK) && (fhc)) 219 cir_service = SERVICE_FHC; 220 else if ((sysinfo_get_value("kbd.cir.obio", &obio) == EOK) && (obio)) 221 cir_service = SERVICE_OBIO; 222 223 if (cir_service) { 224 while (cir_phone < 0) 225 cir_phone = service_connect_blocking(cir_service, 0, 0); 218 if (((sysinfo_get_value("kbd.cir.fhc", &fhc) == EOK) && (fhc)) 219 || ((sysinfo_get_value("kbd.cir.obio", &obio) == EOK) && (obio))) 220 irc_service = true; 221 222 if (irc_service) { 223 while (irc_phone < 0) 224 irc_phone = service_connect_blocking(SERVICE_IRC, 0, 0); 226 225 } 227 226 -
uspace/srv/hid/kbd/include/kbd.h
rd70765d rcd1e6b62 38 38 #define KBD_KBD_H_ 39 39 40 extern int cir_service; 41 extern int cir_phone; 40 #include <bool.h> 41 42 extern bool irc_service; 43 extern int irc_phone; 42 44 43 45 extern void kbd_push_scancode(int); -
uspace/srv/hid/kbd/port/ns16550.c
rd70765d rcd1e6b62 120 120 kbd_push_scancode(scan_code); 121 121 122 if ( cir_service)123 async_msg_1( cir_phone, IRC_CLEAR_INTERRUPT,122 if (irc_service) 123 async_msg_1(irc_phone, IRC_CLEAR_INTERRUPT, 124 124 IPC_GET_IMETHOD(*call)); 125 125 } -
uspace/srv/hid/kbd/port/z8530.c
rd70765d rcd1e6b62 108 108 kbd_push_scancode(scan_code); 109 109 110 if ( cir_service)111 async_msg_1( cir_phone, IRC_CLEAR_INTERRUPT,110 if (irc_service) 111 async_msg_1(irc_phone, IRC_CLEAR_INTERRUPT, 112 112 IPC_GET_IMETHOD(*call)); 113 113 } -
uspace/srv/hw/irc/apic/apic.c
rd70765d rcd1e6b62 54 54 #define NAME "apic" 55 55 56 static bool apic_found = false;57 58 56 static int apic_enable_irq(sysarg_t irq) 59 57 { … … 81 79 callid = async_get_call(&call); 82 80 83 sysarg_t method = IPC_GET_IMETHOD(call); 84 if (method == IPC_M_PHONE_HUNGUP) { 85 return; 86 } 87 88 if (!apic_found) { 89 async_answer_0(callid, ENOTSUP); 90 break; 91 } 92 93 switch (method) { 81 switch (IPC_GET_IMETHOD(call)) { 94 82 case IRC_ENABLE_INTERRUPT: 95 83 async_answer_0(callid, apic_enable_irq(IPC_GET_ARG1(call))); … … 109 97 * 110 98 */ 111 static voidapic_init(void)99 static bool apic_init(void) 112 100 { 113 101 sysarg_t apic; 114 102 115 apic_found = sysinfo_get_value("apic", &apic) && apic;116 if (!apic_found) {117 printf(NAME ": Warning: no APIC found\n");103 if ((sysinfo_get_value("apic", &apic) != EOK) || (!apic)) { 104 printf(NAME ": No APIC found\n"); 105 return false; 118 106 } 119 107 120 108 async_set_client_connection(apic_connection); 121 service_register(SERVICE_APIC); 109 service_register(SERVICE_IRC); 110 111 return true; 122 112 } 123 113 … … 126 116 printf(NAME ": HelenOS APIC driver\n"); 127 117 128 apic_init(); 129 118 if (!apic_init()) 119 return -1; 120 130 121 printf(NAME ": Accepting connections\n"); 131 122 async_manager(); -
uspace/srv/hw/irc/fhc/fhc.c
rd70765d rcd1e6b62 136 136 137 137 async_set_client_connection(fhc_connection); 138 service_register(SERVICE_ FHC);138 service_register(SERVICE_IRC); 139 139 140 140 return true; -
uspace/srv/hw/irc/i8259/i8259.c
rd70765d rcd1e6b62 149 149 150 150 async_set_client_connection(i8259_connection); 151 service_register(SERVICE_I 8259);151 service_register(SERVICE_IRC); 152 152 153 153 return true; -
uspace/srv/hw/irc/obio/obio.c
rd70765d rcd1e6b62 137 137 138 138 async_set_client_connection(obio_connection); 139 service_register(SERVICE_ OBIO);139 service_register(SERVICE_IRC); 140 140 141 141 return true; -
uspace/srv/hw/netif/ne2000/ne2000.c
rd70765d rcd1e6b62 75 75 #define IRQ_GET_TSR(call) ((int) IPC_GET_ARG3(call)) 76 76 77 static int irc_service = 0;77 static bool irc_service = false; 78 78 static int irc_phone = -1; 79 79 … … 383 383 sysarg_t i8259; 384 384 385 if ((sysinfo_get_value("apic", &apic) == EOK) && (apic)) 386 irc_service = SERVICE_APIC; 387 else if ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259)) 388 irc_service = SERVICE_I8259; 385 if (((sysinfo_get_value("apic", &apic) == EOK) && (apic)) 386 || ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259))) 387 irc_service = true; 389 388 390 389 if (irc_service) { 391 390 while (irc_phone < 0) 392 irc_phone = service_connect_blocking( irc_service, 0, 0);391 irc_phone = service_connect_blocking(SERVICE_IRC, 0, 0); 393 392 } 394 393 -
uspace/srv/net/net/net.c
rd70765d rcd1e6b62 289 289 if (rc != EOK) 290 290 return rc; 291 291 292 rc = add_module(NULL, &net_globals.modules, (uint8_t *) NE2000_NAME, 292 293 (uint8_t *) NE2000_FILENAME, SERVICE_NE2000, 0, connect_to_service); 293 294 if (rc != EOK) 294 295 return rc; 296 295 297 rc = add_module(NULL, &net_globals.modules, (uint8_t *) ETHERNET_NAME, 296 298 (uint8_t *) ETHERNET_FILENAME, SERVICE_ETHERNET, 0, connect_to_service); 297 299 if (rc != EOK) 298 300 return rc; 301 299 302 rc = add_module(NULL, &net_globals.modules, (uint8_t *) NILDUMMY_NAME, 300 303 (uint8_t *) NILDUMMY_FILENAME, SERVICE_NILDUMMY, 0, connect_to_service); … … 590 593 rc = start_device(netif); 591 594 if (rc != EOK) { 592 printf("%s: Error startinginterface %s (%s)\n", NAME,595 printf("%s: Ignoring failed interface %s (%s)\n", NAME, 593 596 netif->name, str_error(rc)); 594 597 measured_strings_destroy(&netif->configuration); 595 598 netifs_exclude_index(&net_globals.netifs, index); 596 597 return rc; 599 continue; 598 600 } 599 601 -
uspace/srv/vfs/vfs_ops.c
rd70765d rcd1e6b62 1234 1234 if (!parentc) { 1235 1235 fibril_rwlock_write_unlock(&namespace_rwlock); 1236 vfs_node_put(old_node); 1236 1237 async_answer_0(rid, rc); 1237 1238 free(old); … … 1251 1252 if (rc != EOK) { 1252 1253 fibril_rwlock_write_unlock(&namespace_rwlock); 1254 vfs_node_put(old_node); 1253 1255 async_answer_0(rid, rc); 1254 1256 free(old); … … 1261 1263 (old_node->devmap_handle != new_par_lr.triplet.devmap_handle)) { 1262 1264 fibril_rwlock_write_unlock(&namespace_rwlock); 1265 vfs_node_put(old_node); 1263 1266 async_answer_0(rid, EXDEV); /* different file systems */ 1264 1267 free(old); … … 1279 1282 if (!new_node) { 1280 1283 fibril_rwlock_write_unlock(&namespace_rwlock); 1284 vfs_node_put(old_node); 1281 1285 async_answer_0(rid, ENOMEM); 1282 1286 free(old); … … 1290 1294 default: 1291 1295 fibril_rwlock_write_unlock(&namespace_rwlock); 1296 vfs_node_put(old_node); 1292 1297 async_answer_0(rid, ENOTEMPTY); 1293 1298 free(old); … … 1300 1305 if (rc != EOK) { 1301 1306 fibril_rwlock_write_unlock(&namespace_rwlock); 1307 vfs_node_put(old_node); 1302 1308 if (new_node) 1303 1309 vfs_node_put(new_node); -
version
rd70765d rcd1e6b62 37 37 VERSION = 0 38 38 PATCHLEVEL = 4 39 SUBLEVEL = 239 SUBLEVEL = 3 40 40 41 41 ifdef EXTRAVERSION … … 45 45 endif 46 46 47 NAME = S kewer47 NAME = Sashimi
Note:
See TracChangeset
for help on using the changeset viewer.