Changes in / [d9f53877:9d58539] in mainline


Ignore:
Files:
3 added
3 deleted
38 edited

Legend:

Unmodified
Added
Removed

  • tools/check.sh

    rd9f53877 r9d58539  
    6666do
    6767        echo -n ">>>> Building $P... "
    68         ( make distclean && make PROFILE=$P HANDS_OFF=y "$@" ) >>/dev/null 2>>/dev/null
     68        ( make distclean && make PROFILE=$P HANDS_OFF=y $1 ) >>/dev/null 2>>/dev/null
    6969        if [ $? -ne 0 ];
    7070        then

  • tools/checkers/clang.py

    rd9f53877 r9d58539  
    114114        for job in jobs:
    115115                if (not clang(rootdir, job)):
    116                         print()
     116                        print
    117117                        print("Failed job: %s" % job)
    118118                        return

  • tools/checkers/stanse.py

    rd9f53877 r9d58539  
    127127        for job in jobs:
    128128                if (not stanse(rootdir, job)):
    129                         print()
     129                        print
    130130                        print("Failed job: %s" % job)
    131131                        return

  • tools/checkers/vcc.py

    rd9f53877 r9d58539  
    204204        for job in jobs:
    205205                if (not vcc(vcc_path, rootdir, job)):
    206                         print()
     206                        print
    207207                        print("Failed job: %s" % job)
    208208                        return
    209209       
    210         print()
     210        print
    211211        print("All jobs passed")
    212212

  • tools/filldir.py

    rd9f53877 r9d58539  
    3737
    3838if len(sys.argv) < 3:
    39         print('Usage: filldir <parent-dir> <count>')
     39        print 'Usage: filldir <parent-dir> <count>'
    4040        exit(2)
    4141

  • tools/gentestfile.py

    rd9f53877 r9d58539  
    3636
    3737if len(sys.argv) < 2:
    38         print("Usage: gentestfile.py <count of 64-bit numbers to output>")
     38        print "Usage: gentestfile.py <count of 64-bit numbers to output>"
    3939        exit()
    4040
    41 m = int(sys.argv[1])
     41m = long(sys.argv[1])
    4242i = 0
    4343pow_2_64 = 2 ** 64

  • tools/mkfat.py

    rd9f53877 r9d58539  
    168168"""
    169169
    170 LFN_ENTRY = """little:
    171         uint8_t pos
    172         uint16_t name1[5]
    173         uint8_t attr
    174         uint8_t type
    175         uint8_t csum
    176         uint16_t name2[6]
    177         uint16_t fc
    178         uint16_t name3[2]
    179 """
    180 
    181 # Global variable to hold the file names in 8.3 format. Needed to
    182 # keep track of "number" when creating a short fname from a LFN.
    183 name83_list = []
    184 
    185 def name83(fname):
    186         "Create a 8.3 name for the given fname"
    187 
     170def mangle_fname(name):
    188171        # FIXME: filter illegal characters
    189         parts = fname.split('.')
    190        
    191         name = ''
    192         ext = ''
    193         lfn = False
    194 
    195         if len(fname) > 11 :
    196                 lfn = True
    197 
     172        parts = name.split('.')
     173       
    198174        if len(parts) > 0:
    199                 name = parts[0]
    200                 if len(name) > 8 :
    201                         lfn = True
    202 
    203         if len(parts) > 1 :
    204                 ext = parts[-1]
    205                 if len(ext) > 3 :
    206                         lfn = True
    207 
    208         if len(parts) > 2 :
    209                 lfn = True
    210 
    211         if (lfn == False) :
    212                 return (name.ljust(8)[0:8], ext.ljust(3)[0:3], False)
    213 
    214         # For filenames with multiple extensions, we treat the last one
    215         # as the actual extension. The rest of the filename is stripped
    216         # of dots and concatenated to form the short name
    217         for _name in parts[1:-1]:
    218                 name = name + _name             
    219 
    220         global name83_list
    221         for number in range(1, 10000) :
    222                 number_str = '~' + str(number)
    223 
    224                 if len(name) + len(number_str) > 8 :
    225                         name = name[0:8 - len(number_str)]
    226 
    227                 name = name + number_str;
    228 
    229                 if (name + ext) not in name83_list :
    230                         break
    231                        
    232         name83_list.append(name + ext) 
    233 
    234         return (name.ljust(8)[0:8], ext.ljust(3)[0:3], True)
    235 
    236 def get_utf16(name, l) :
    237         "Create a int array out of a string which we can store in uint16_t arrays"
    238 
    239         bs = [0xFFFF for i in range(l)]
    240 
    241         for i in range(len(name)) :
    242                 bs[i] = ord(name[i])
    243        
    244         if (len(name) < l) :
    245                 bs[len(name)] = 0;
    246        
    247         return bs
    248 
    249 def create_lfn_entry(name_index) :
    250         (name, index) = name_index
    251         entry = xstruct.create(LFN_ENTRY)
    252 
    253         entry.name1 = get_utf16(name[0:5], 5)
    254         entry.name2 = get_utf16(name[5:11], 6)
    255         entry.name3 = get_utf16(name[11:13], 2)
    256         entry.pos = index
    257 
    258         entry.attr = 0xF
    259         entry.fc = 0
    260         entry.type = 0
    261 
    262         return entry
     175                fname = parts[0]
     176        else:
     177                fname = ''
     178       
     179        if len(fname) > 8:
     180                sys.stdout.write("mkfat.py: error: Directory entry " + name +
     181                    " base name is longer than 8 characters\n")
     182                sys.exit(1);
     183       
     184        return (fname + '          ').upper()[0:8]
     185
     186def mangle_ext(name):
     187        # FIXME: filter illegal characters
     188        parts = name.split('.')
     189       
     190        if len(parts) > 1:
     191                ext = parts[1]
     192        else:
     193                ext = ''
     194       
     195        if len(parts) > 2:
     196                sys.stdout.write("mkfat.py: error: Directory entry " + name +
     197                    " has more than one extension\n")
     198                sys.exit(1);
     199       
     200        if len(ext) > 3:
     201                sys.stdout.write("mkfat.py: error: Directory entry " + name +
     202                    " extension is longer than 3 characters\n")
     203                sys.exit(1);
     204       
     205        return (ext + '   ').upper()[0:3]
    263206
    264207def create_dirent(name, directory, cluster, size):
    265        
    266208        dir_entry = xstruct.create(DIR_ENTRY)
    267209       
    268         dir_entry.name, dir_entry.ext, lfn = name83(name)
    269 
    270         dir_entry.name = dir_entry.name.upper().encode('ascii')
    271         dir_entry.ext = dir_entry.ext.upper().encode('ascii')
    272 
     210        dir_entry.name = mangle_fname(name).encode('ascii')
     211        dir_entry.ext = mangle_ext(name).encode('ascii')
     212       
    273213        if (directory):
    274214                dir_entry.attr = 0x30
    … …  
    290230                dir_entry.size = size
    291231       
    292 
    293         if not lfn:
    294                 return [dir_entry]
    295 
    296         n = (int) (len(name) / 13 + 1)
    297         names = [(name[i * 13: (i + 1) * 13 + 1], i + 1) for i in range(n)]
    298 
    299         entries = sorted(map (create_lfn_entry, names), reverse = True, key = lambda e : e.pos)
    300         entries[0].pos |= 0x40
    301 
    302         fname11 = str(dir_entry.name + dir_entry.ext)
    303 
    304         csum = 0
    305         for i in range(0, 11) :
    306                 csum = ((csum & 1) << 7) + (csum  >> 1) + ord(fname11[i])
    307                 csum = csum & 0xFF
    308        
    309         for e in entries :
    310                 e.csum = csum;
    311        
    312         entries.append(dir_entry)
    313 
    314         return entries
     232        return dir_entry
    315233
    316234def create_dot_dirent(empty_cluster):
    … …  
    370288                if item.is_file:
    371289                        rv = write_file(item, outf, cluster_size, data_start, fat, reserved_clusters)
    372                         directory.extend(create_dirent(item.name, False, rv[0], rv[1]))
     290                        directory.append(create_dirent(item.name, False, rv[0], rv[1]))
    373291                elif item.is_dir:
    374292                        rv = recursion(False, item.path, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, empty_cluster)
    375                         directory.extend(create_dirent(item.name, True, rv[0], rv[1]))
     293                        directory.append(create_dirent(item.name, True, rv[0], rv[1]))
    376294       
    377295        if (head):

  • tools/mkuimage.py

    rd9f53877 r9d58539  
    124124        header.img_type = 2             # Kernel
    125125        header.compression = 0          # None
    126         header.img_name = image_name.encode('ascii')
     126        header.img_name = image_name
    127127
    128128        header_crc = calc_crc32(header.pack())
    … …  
    140140        signed_crc = zlib.crc32(byteseq, 0)
    141141        if signed_crc < 0:
    142                 return signed_crc + (1 << 32)
     142                return (long(signed_crc) + (long(2) ** long(32))) # 2^32L
    143143        else:
    144144                return signed_crc
    … …  
    148148def print_syntax(cmd):
    149149        print("syntax: " + cmd + " [<options>] <raw_image> <uImage>")
    150         print()
     150        print
    151151        print("\traw_image\tInput image name (raw binary data)")
    152152        print("\tuImage\t\tOutput uImage name (U-Boot image)")
    153         print()
     153        print
    154154        print("options:")
    155155        print("\t-name <name>\tImage name (default: 'Noname')")

  • tools/xstruct.py

    rd9f53877 r9d58539  
    3232
    3333import struct
    34 import sys
    3534import types
    3635
    37 integer_types = (int, long) if sys.version < '3' else (int,)
    38 
    3936ranges = {
    40         'B': (integer_types, 0x00, 0xff),
    41         'H': (integer_types, 0x0000, 0xffff),
    42         'L': (integer_types, 0x00000000, 0xffffffff),
    43         'Q': (integer_types, 0x0000000000000000, 0xffffffffffffffff),
    44         'b': (integer_types, -0x80, 0x7f),
    45         'h': (integer_types, -0x8000, 0x7fff),
    46         'l': (integer_types, -0x80000000, 0x7fffffff) ,
    47         'q': (integer_types, -0x8000000000000000, 0x7fffffffffffffff),
     37        'B': ((int, long), 0x00, 0xff),
     38        'H': ((int, long), 0x0000, 0xffff),
     39        'L': ((int, long), 0x00000000, 0xffffffff),
     40        'Q': ((int, long), 0x0000000000000000, 0xffffffffffffffff),
     41        'b': ((int, long), -0x80, 0x7f),
     42        'h': ((int, long), -0x8000, 0x7fff),
     43        'l': ((int, long), -0x80000000, 0x7fffffff) ,
     44        'q': ((int, long), -0x8000000000000000, 0x7fffffffffffffff),
    4845}
    4946

  • uspace/app/bdsh/cmds/builtins/cd/cd.c

    rd9f53877 r9d58539  
    6363        argc = cli_count_args(argv);
    6464
    65         /* Handle cd -- -. Override to switch to a directory named '-' */
    66         bool hyphen_override = false;
    67         if (argc == 3) {
    68                 if(!str_cmp(argv[1], "--")) {
    69                         hyphen_override = true;
    70                         argc--;
    71                 }
    72         }
    73 
    7465        /* We don't yet play nice with whitespace, a getopt implementation should
    7566         * protect "quoted\ destination" as a single argument. Its not our job to
    … …  
    8879        }
    8980
    90         /* We have the correct # of arguments */
    91         // TODO: handle tidle (~) expansion? */
     81        /* We have the correct # of arguments
     82     * TODO: handle tidle (~) expansion? */
    9283
    93         /* Handle 'cd -' first. */
    94         if (!str_cmp(argv[1], "-") && !hyphen_override) {
    95                 char *buffer = (char *) malloc(PATH_MAX);
    96                 if (!buffer) {
    97                         cli_error(CL_ENOMEM, "Cannot switch to previous directory");
    98                         return CMD_FAILURE;
    99                 }
    100                 memset(buffer, 0, PATH_MAX);
    101                 getprevwd(buffer, PATH_MAX);
    102                 if (*buffer == '\0') {
    103                         cli_error(CL_EFAIL, "No previous directory to switch to");
    104                         free(buffer);
    105                         return CMD_FAILURE;
    106                 } else {
    107                         rc = chdir(buffer);
    108                         free(buffer);
    109                 }
    110         } else if (hyphen_override) {
    111                 /* Handles 'cd -- <dirname>'.
    112                  * Override for directory named '-'.
    113                  */
    114                 rc = chdir(argv[2]);
    115         } else {
    116                 rc = chdir(argv[1]);
    117         }
     84        rc = chdir(argv[1]);
    11885
    11986        if (rc == 0) {

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

    rd9f53877 r9d58539  
    5252#define CAT_VERSION "0.0.1"
    5353#define CAT_DEFAULT_BUFLEN 1024
    54 #define CAT_FULL_FILE 0
    55 
     54
     55static const char *cat_oops = "That option is not yet supported\n";
    5656static const char *hexchars = "0123456789abcdef";
    5757
    … …  
    163163}
    164164
    165 static unsigned int cat_file(const char *fname, size_t blen, bool hex,
    166     off64_t head, off64_t tail, bool tail_first)
     165static unsigned int cat_file(const char *fname, size_t blen, bool hex)
    167166{
    168167        int fd, bytes = 0, count = 0, reads = 0;
    169168        char *buff = NULL;
    170169        int i;
    171         size_t offset = 0, copied_bytes = 0;
    172         off64_t file_size = 0, length = 0;
     170        size_t offset = 0;
    173171
    174172        fd = open(fname, O_RDONLY);
    … …  
    185183        }
    186184
    187         if (tail != CAT_FULL_FILE) {
    188                 file_size = lseek(fd, 0, SEEK_END);
    189                 if (head == CAT_FULL_FILE) {
    190                         head = file_size;
    191                         length = tail;
    192                 } else if (tail_first) {
    193                         length = head;
    194                 } else {
    195                         if (tail > head)
    196                                 tail = head;
    197                         length = tail;
    198                 }
    199 
    200                 if (tail_first) {
    201                         lseek(fd, (tail >= file_size) ? 0 : (file_size - tail), SEEK_SET);
    202                 } else {
    203                         lseek(fd, ((head - tail) >= file_size) ? 0 : (head - tail), SEEK_SET);
    204                 }
    205         } else
    206                 length = head;
    207 
    208185        do {
    209                 bytes = read(fd, buff + copied_bytes, (
    210                         (length != CAT_FULL_FILE && length - (off64_t)count <= (off64_t)(blen - copied_bytes)) ?
    211                         (size_t)(length - count) :
    212                         (blen - copied_bytes) ) );
    213                 bytes += copied_bytes;
    214                 copied_bytes = 0;
    215 
     186                bytes = read(fd, buff, blen);
    216187                if (bytes > 0) {
     188                        count += bytes;
    217189                        buff[bytes] = '\0';
    218190                        offset = 0;
    … …  
    221193                                        paged_char(hexchars[((uint8_t)buff[i])/16]);
    222194                                        paged_char(hexchars[((uint8_t)buff[i])%16]);
    223                                         paged_char(((count+i+1) & 0xf) == 0 ? '\n' : ' ');
    224195                                }
    225196                                else {
    … …  
    228199                                                /* Reached end of string */
    229200                                                break;
    230                                         } else if (c == U_SPECIAL && offset + 2 >= (size_t)bytes) {
    231                                                 /* If an extended character is cut off due to the size of the buffer,
    232                                                    we will copy it over to the next buffer so it can be read correctly. */
    233                                                 copied_bytes = bytes - offset + 1;
    234                                                 memcpy(buff, buff + offset - 1, copied_bytes);
    235                                                 break;
    236201                                        }
    237202                                        paged_char(c);
    … …  
    239204                               
    240205                        }
    241                         count += bytes;
    242206                        reads++;
    243207                }
    244         } while (bytes > 0 && !should_quit && (count < length || length == CAT_FULL_FILE));
     208        } while (bytes > 0 && !should_quit);
    245209
    246210        close(fd);
    … …  
    259223int cmd_cat(char **argv)
    260224{
    261         unsigned int argc, i, ret = 0;
    262         size_t buffer = 0;
     225        unsigned int argc, i, ret = 0, buffer = 0;
    263226        int c, opt_ind;
    264         aoff64_t head = CAT_FULL_FILE, tail = CAT_FULL_FILE;
    265227        bool hex = false;
    266228        bool more = false;
    267         bool tailFirst = false;
    268229        sysarg_t rows, cols;
    269230        int rc;
    … …  
    293254                        return CMD_SUCCESS;
    294255                case 'H':
    295                         if (!optarg || str_uint64_t(optarg, NULL, 10, false, &head) != EOK ) {
    296                                 puts("Invalid head size\n");
    297                                 return CMD_FAILURE;
    298                         }
    299                         break;
     256                        printf("%s", cat_oops);
     257                        return CMD_FAILURE;
    300258                case 't':
    301                         if (!optarg || str_uint64_t(optarg, NULL, 10, false, &tail) != EOK ) {
    302                                 puts("Invalid tail size\n");
    303                                 return CMD_FAILURE;
    304                         }
    305                         if (head == CAT_FULL_FILE)
    306                                 tailFirst = true;
    307                         break;
     259                        printf("%s", cat_oops);
     260                        return CMD_FAILURE;
    308261                case 'b':
    309                         if (!optarg || str_size_t(optarg, NULL, 10, false, &buffer) != EOK ) {
    310                                 puts("Invalid buffer size\n");
    311                                 return CMD_FAILURE;
    312                         }
     262                        printf("%s", cat_oops);
    313263                        break;
    314264                case 'm':
    … …  
    329279        }
    330280
    331         if (buffer < 4)
     281        if (buffer <= 0)
    332282                buffer = CAT_DEFAULT_BUFLEN;
    333283       
    … …  
    345295
    346296        for (i = optind; argv[i] != NULL && !should_quit; i++)
    347                 ret += cat_file(argv[i], buffer, hex, head, tail, tailFirst);
     297                ret += cat_file(argv[i], buffer, hex);
    348298
    349299        if (ret)

  • uspace/app/bdsh/cmds/modules/cat/cat.h

    rd9f53877 r9d58539  
    44/* Prototypes for the cat command, excluding entry points */
    55
     6static unsigned int cat_file(const char *, size_t, bool);
     7
    68#endif /* CAT_H */
    79

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

    rd9f53877 r9d58539  
    3030#include <stdlib.h>
    3131#include <unistd.h>
    32 #include <io/console.h>
    33 #include <io/keycode.h>
    3432#include <getopt.h>
    3533#include <str.h>
    … …  
    4846
    4947static const char *cmdname = "cp";
    50 static console_ctrl_t *con;
    5148
    5249static struct option const long_options[] = {
    5350        { "buffer", required_argument, 0, 'b' },
    5451        { "force", no_argument, 0, 'f' },
    55         { "interactive", no_argument, 0, 'i'},
    5652        { "recursive", no_argument, 0, 'r' },
    5753        { "help", no_argument, 0, 'h' },
    … …  
    143139}
    144140
    145 static bool get_user_decision(bool bdefault, const char *message, ...)
    146 {
    147         va_list args;
    148 
    149         va_start(args, message);
    150         vprintf(message, args);
    151         va_end(args);
    152 
    153         while (true) {
    154                 kbd_event_t ev;
    155                 console_flush(con);
    156                 console_get_kbd_event(con, &ev);
    157                 if ((ev.type != KEY_PRESS)
    158                     || (ev.mods & (KM_CTRL | KM_ALT)) != 0) {
    159                         continue;
    160                 }
    161 
    162                 switch(ev.key) {
    163                 case KC_Y:
    164                         printf("y\n");
    165                         return true;
    166                 case KC_N:
    167                         printf("n\n");
    168                         return false;
    169                 case KC_ENTER:
    170                         printf("%c\n", bdefault ? 'Y' : 'N');
    171                         return bdefault;
    172                 default:
    173                         break;
    174                 }
    175         }
    176 }
    177 
    178141static int64_t do_copy(const char *src, const char *dest,
    179     size_t blen, int vb, int recursive, int force, int interactive)
     142    size_t blen, int vb, int recursive, int force)
    180143{
    181144        int r = -1;
    … …  
    229192                        /* e.g. cp file_name existing_file */
    230193
    231                         /* dest already exists,
    232                          * if force is set we will try to remove it.
    233                          * if interactive is set user input is required.
     194                        /* dest already exists, if force is set we will
     195                         * try to remove it.
    234196                         */
    235                         if (force && !interactive) {
     197                        if (force) {
    236198                                if (unlink(dest_path)) {
    237199                                        printf("Unable to remove %s\n",
    … …  
    239201                                        goto exit;
    240202                                }
    241                         } else if (!force && interactive) {
    242                                 bool overwrite = get_user_decision(false,
    243                                     "File already exists: %s. Overwrite? [y/N]: ",
    244                                     dest_path);
    245                                 if (overwrite) {
    246                                         printf("Overwriting file: %s\n", dest_path);
    247                                         if (unlink(dest_path)) {
    248                                                 printf("Unable to remove %s\n", dest_path);
    249                                                 goto exit;
    250                                         }
    251                                 } else {
    252                                         printf("Not overwriting file: %s\n", dest_path);
    253                                         r = 0;
    254                                         goto exit;
    255                                 }
    256203                        } else {
    257                                 printf("File already exists: %s\n", dest_path);
     204                                printf("file already exists: %s\n", dest_path);
    258205                                goto exit;
    259206                        }
    … …  
    355302                        /* Recursively call do_copy() */
    356303                        r = do_copy(src_dent, dest_dent, blen, vb, recursive,
    357                             force, interactive);
     304                            force);
    358305                        if (r)
    359306                                goto exit;
    … …  
    368315        return r;
    369316}
     317
    370318
    371319static int64_t copy_file(const char *src, const char *dest,
    … …  
    432380            "  -v, --version    Print version information and exit\n"
    433381            "  -V, --verbose    Be annoyingly noisy about what's being done\n"
    434             "  -f, --force      Do not complain when <dest> exists (overrides a previous -i)\n"
    435             "  -i, --interactive Ask what to do when <dest> exists (overrides a previous -f)\n"
     382            "  -f, --force      Do not complain when <dest> exists\n"
    436383            "  -r, --recursive  Copy entire directories\n"
    437384            "  -b, --buffer ## Set the read buffer size to ##\n";
    … …  
    450397        unsigned int argc, verbose = 0;
    451398        int buffer = 0, recursive = 0;
    452         int force = 0, interactive = 0;
     399        int force = 0;
    453400        int c, opt_ind;
    454401        int64_t ret;
    455402
    456         con = console_init(stdin, stdout);
    457403        argc = cli_count_args(argv);
    458404
    459405        for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
    460                 c = getopt_long(argc, argv, "hvVfirb:", long_options, &opt_ind);
     406                c = getopt_long(argc, argv, "hvVfrb:", long_options, &opt_ind);
    461407                switch (c) {
    462408                case 'h':
    … …  
    470416                        break;
    471417                case 'f':
    472                         interactive = 0;
    473418                        force = 1;
    474                         break;
    475                 case 'i':
    476                         force = 0;
    477                         interactive = 1;
    478419                        break;
    479420                case 'r':
    … …  
    485426                                    "(should be a number greater than zero)\n",
    486427                                    cmdname);
    487                                 console_done(con);
    488428                                return CMD_FAILURE;
    489429                        }
    … …  
    502442                printf("%s: invalid number of arguments. Try %s --help\n",
    503443                    cmdname, cmdname);
    504                 console_done(con);
    505444                return CMD_FAILURE;
    506445        }
    507446
    508447        ret = do_copy(argv[optind], argv[optind + 1], buffer, verbose,
    509             recursive, force, interactive);
    510 
    511         console_done(con);
     448            recursive, force);
    512449
    513450        if (ret == 0)

  • uspace/app/bdsh/cmds/modules/help/help.h

    rd9f53877 r9d58539  
    33
    44/* Prototypes for the help command (excluding entry points) */
     5static int is_mod_or_builtin(char *);
    56
    67#endif

  • uspace/app/bdsh/cmds/modules/mkdir/mkdir.h

    rd9f53877 r9d58539  
    44/* Prototypes for the mkdir command, excluding entry points */
    55
     6static unsigned int create_directory(const char *, unsigned int);
    67#endif /* MKDIR_H */
    78

  • uspace/app/bdsh/cmds/modules/printf/TODO

    rd9f53877 r9d58539  
    1111 * Add width/precision options for number printings
    1212 * Add more format flags (%f %b ...)
    13  

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

    rd9f53877 r9d58539  
    4747                help_cmd_printf(HELP_SHORT);
    4848                printf(
    49                     "Usage:  %s FORMAT [ARGS ...] \n"
    50                     "Prints ARGS according to FORMAT. Number of expected arguments in\n"
    51                     "FORMAT must be equals to the number of ARGS. Currently supported\n"
    52                     "format flags are:\n",
    53                     cmdname);
     49                "Usage:  %s FORMAT [ARGS ...] \n"
     50                "Prints ARGS according to FORMAT. Number of expected arguments in\n"
     51                "FORMAT must be equals to the number of ARGS. Currently supported\n"
     52                "format flags are:\n",
     53                cmdname);
    5454        }
    5555
    … …  
    172172                        break;
    173173
    174                 emit:
    175                         putchar(ch);
    176                         esc_flag = false;
     174                emit:           putchar(ch);
     175                                esc_flag = false;
    177176                }
    178177        }       

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

    rd9f53877 r9d58539  
    4646#define RM_VERSION "0.0.1"
    4747
     48static rm_job_t rm;
     49
    4850static struct option const long_options[] = {
    4951        { "help", no_argument, 0, 'h' },
    … …  
    5557};
    5658
    57 /* Return values for rm_scope() */
    58 #define RM_BOGUS 0
    59 #define RM_FILE  1
    60 #define RM_DIR   2
    61 
    62 /* Flags for rm_update() */
    63 #define _RM_ENTRY   0
    64 #define _RM_ADVANCE 1
    65 #define _RM_REWIND  2
    66 #define _RM_EXIT    3
    67 
    68 /* A simple job structure */
    69 typedef struct {
    70         /* Options set at run time */
    71         unsigned int force;      /* -f option */
    72         unsigned int recursive;  /* -r option */
    73         unsigned int safe;       /* -s option */
    74 
    75         /* Keeps track of the job in progress */
    76         int advance; /* How far deep we've gone since entering */
    77         DIR *entry;  /* Entry point to the tree being removed */
    78         char *owd;   /* Where we were when we invoked rm */
    79         char *cwd;   /* Current directory being transversed */
    80         char *nwd;   /* Next directory to be transversed */
    81 
    82         /* Counters */
    83         int f_removed; /* Number of files unlinked */
    84         int d_removed; /* Number of directories unlinked */
    85 } rm_job_t;
    86 
    87 static rm_job_t rm;
    88 
    89 static unsigned int rm_recursive(const char *);
    90 
    9159static unsigned int rm_start(rm_job_t *rm)
    9260{
    … …  
    12795        if (NULL != rm->cwd)
    12896                free(rm->cwd);
    129 }
    130 
    131 static unsigned int rm_single(const char *path)
    132 {
    133         if (unlink(path)) {
    134                 cli_error(CL_EFAIL, "rm: could not remove file %s", path);
    135                 return 1;
    136         }
    137         return 0;
    138 }
    139 
    140 static unsigned int rm_scope(const char *path)
    141 {
    142         int fd;
    143         DIR *dirp;
    144 
    145         dirp = opendir(path);
    146         if (dirp) {
    147                 closedir(dirp);
    148                 return RM_DIR;
    149         }
    150 
    151         fd = open(path, O_RDONLY);
    152         if (fd > 0) {
    153                 close(fd);
    154                 return RM_FILE;
    155         }
    156 
    157         return RM_BOGUS;
    15897}
    15998
    … …  
    215154
    216155        return ret + 1;
     156}
     157
     158static unsigned int rm_single(const char *path)
     159{
     160        if (unlink(path)) {
     161                cli_error(CL_EFAIL, "rm: could not remove file %s", path);
     162                return 1;
     163        }
     164        return 0;
     165}
     166
     167static unsigned int rm_scope(const char *path)
     168{
     169        int fd;
     170        DIR *dirp;
     171
     172        dirp = opendir(path);
     173        if (dirp) {
     174                closedir(dirp);
     175                return RM_DIR;
     176        }
     177
     178        fd = open(path, O_RDONLY);
     179        if (fd > 0) {
     180                close(fd);
     181                return RM_FILE;
     182        }
     183
     184        return RM_BOGUS;
    217185}
    218186

  • uspace/app/bdsh/cmds/modules/rm/rm.h

    rd9f53877 r9d58539  
    22#define RM_H
    33
     4/* Return values for rm_scope() */
     5#define RM_BOGUS 0
     6#define RM_FILE  1
     7#define RM_DIR   2
     8
     9/* Flags for rm_update() */
     10#define _RM_ENTRY   0
     11#define _RM_ADVANCE 1
     12#define _RM_REWIND  2
     13#define _RM_EXIT    3
     14
     15/* A simple job structure */
     16typedef struct {
     17        /* Options set at run time */
     18        unsigned int force;      /* -f option */
     19        unsigned int recursive;  /* -r option */
     20        unsigned int safe;       /* -s option */
     21
     22        /* Keeps track of the job in progress */
     23        int advance; /* How far deep we've gone since entering */
     24        DIR *entry;  /* Entry point to the tree being removed */
     25        char *owd;   /* Where we were when we invoked rm */
     26        char *cwd;   /* Current directory being transversed */
     27        char *nwd;   /* Next directory to be transversed */
     28
     29        /* Counters */
     30        int f_removed; /* Number of files unlinked */
     31        int d_removed; /* Number of directories unlinked */
     32} rm_job_t;
     33
     34
    435/* Prototypes for the rm command, excluding entry points */
     36static unsigned int rm_start(rm_job_t *);
     37static void rm_end(rm_job_t *rm);
     38static unsigned int rm_recursive(const char *);
     39static unsigned int rm_single(const char *);
     40static unsigned int rm_scope(const char *);
    541
    642#endif /* RM_H */

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

    rd9f53877 r9d58539  
    2727 */
    2828
    29 #include <errno.h>
    3029#include <stdio.h>
    3130#include <stdlib.h>
    32 #include <unistd.h>
    3331#include "config.h"
    3432#include "util.h"
    … …  
    4341void help_cmd_sleep(unsigned int level)
    4442{
    45         if (level == HELP_SHORT) {
    46                 printf("`%s' pauses for a given time interval\n", cmdname);
    47         } else {
    48                 help_cmd_sleep(HELP_SHORT);
    49                 printf(
    50                     "Usage:  %s <duration>\n"
    51                     "The duration is a decimal number of seconds.\n",
    52                     cmdname);
    53         }
    54 
     43        printf("This is the %s help for '%s'.\n",
     44                level ? EXT_HELP : SHORT_HELP, cmdname);
    5545        return;
    56 }
    57 
    58 /** Convert string containing decimal seconds to useconds_t.
    59  *
    60  * @param nptr   Pointer to string.
    61  * @param result Result of the conversion.
    62  * @return EOK if conversion was successful.
    63  */
    64 static int decimal_to_useconds(const char *nptr, useconds_t *result)
    65 {
    66         int ret;
    67         uint64_t whole_seconds;
    68         uint64_t frac_seconds;
    69         char *endptr;
    70 
    71         /* Check for whole seconds */
    72         if (*nptr == '.') {
    73                 whole_seconds = 0;
    74                 endptr = (char *)nptr;
    75         } else {
    76                 ret = str_uint64_t(nptr, &endptr, 10, false, &whole_seconds);
    77                 if (ret != EOK)
    78                         return ret;
    79         }
    80 
    81         /* Check for fractional seconds */
    82         if (*endptr == '\0') {
    83                 frac_seconds = 0;
    84         } else if (*endptr == '.' && endptr[1] == '\0') {
    85                 frac_seconds = 0;
    86         } else if (*endptr == '.') {
    87                 nptr = endptr + 1;
    88                 ret = str_uint64_t(nptr, &endptr, 10, true, &frac_seconds);
    89                 if (ret != EOK)
    90                         return ret;
    91 
    92                 int ndigits = endptr - nptr;
    93                 for (; ndigits < 6; ndigits++)
    94                         frac_seconds *= 10;
    95                 for (; ndigits > 6; ndigits--)
    96                         frac_seconds /= 10;
    97         } else {
    98                 return EINVAL;
    99         }
    100 
    101         /* Check for overflow */
    102         useconds_t total = whole_seconds * 1000000 + frac_seconds;
    103         if (total / 1000000 != whole_seconds)
    104                 return EOVERFLOW;
    105 
    106         *result = total;
    107 
    108         return EOK;
    10946}
    11047
    … …  
    11249int cmd_sleep(char **argv)
    11350{
    114         int ret;
    11551        unsigned int argc;
    116         useconds_t duration;
     52        unsigned int i;
    11753
    11854        /* Count the arguments */
    119         argc = cli_count_args(argv);
     55        for (argc = 0; argv[argc] != NULL; argc ++);
    12056
    121         if (argc != 2) {
    122                 printf("%s - incorrect number of arguments. Try `help %s'\n",
    123                     cmdname, cmdname);
    124                 return CMD_FAILURE;
     57        printf("%s %s\n", TEST_ANNOUNCE, cmdname);
     58        printf("%d arguments passed to %s", argc - 1, cmdname);
     59
     60        if (argc < 2) {
     61                printf("\n");
     62                return CMD_SUCCESS;
    12563        }
    12664
    127         ret = decimal_to_useconds(argv[1], &duration);
    128         if (ret != EOK) {
    129                 printf("%s - invalid duration.\n", cmdname);
    130                 return CMD_FAILURE;
    131         }
    132 
    133         (void) usleep(duration);
     65        printf(":\n");
     66        for (i = 1; i < argc; i++)
     67                printf("[%d] -> %s\n", i, argv[i]);
    13468
    13569        return CMD_SUCCESS;

  • uspace/app/sportdmp/sportdmp.c

    rd9f53877 r9d58539  
    2727 */
    2828
     29#include <errno.h>
     30#include <stdio.h>
     31#include <devman.h>
     32#include <ipc/devman.h>
    2933#include <device/char_dev.h>
    30 #include <errno.h>
    3134#include <ipc/serial_ctl.h>
    32 #include <loc.h>
    33 #include <stdio.h>
    3435
    3536#define BUF_SIZE 1
    3637
    37 static void syntax_print(void)
    38 {
    39         fprintf(stderr, "Usage: sportdmp <baud> <device_service>\n");
     38static void syntax_print() {
     39        fprintf(stderr, "Usage: sportdmp <baud> <device_path>\n");
    4040}
    4141
    4242int main(int argc, char **argv)
    4343{
    44         const char* svc_path = "devices/\\hw\\pci0\\00:01.0\\com1\\a";
     44        const char* devpath = "/hw/pci0/00:01.0/com1/a";
    4545        sysarg_t baud = 9600;
    4646       
    … …  
    5656       
    5757        if (argc > 2) {
    58                 svc_path = argv[2];
     58                devpath = argv[2];
    5959        }
    6060       
    … …  
    6464        }
    6565       
    66         service_id_t svc_id;
    67         int rc = loc_service_get_id(svc_path, &svc_id, IPC_FLAG_BLOCKING);
     66        devman_handle_t device;
     67        int rc = devman_fun_get_handle(devpath, &device, IPC_FLAG_BLOCKING);
    6868        if (rc != EOK) {
    69                 fprintf(stderr, "Cannot find device service %s\n", svc_path);
     69                fprintf(stderr, "Cannot open device %s\n", devpath);
    7070                return 1;
    7171        }
    7272       
    73         async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE, svc_id,
     73        async_sess_t *sess = devman_device_connect(EXCHANGE_SERIALIZE, device,
    7474            IPC_FLAG_BLOCKING);
    7575        if (!sess) {
    76                 fprintf(stderr, "Failed connecting to service %s\n", svc_path);
     76                fprintf(stderr, "Cannot connect device\n");
    7777        }
    7878       
    … …  
    8383       
    8484        if (rc != EOK) {
    85                 fprintf(stderr, "Failed setting serial properties\n");
     85                fprintf(stderr, "Cannot set serial properties\n");
    8686                return 2;
    8787        }
    … …  
    8989        uint8_t *buf = (uint8_t *) malloc(BUF_SIZE);
    9090        if (buf == NULL) {
    91                 fprintf(stderr, "Failed allocating buffer\n");
     91                fprintf(stderr, "Cannot allocate buffer\n");
    9292                return 3;
    9393        }

  • uspace/app/tester/hw/serial/serial1.c

    rd9f53877 r9d58539  
    4242#include <async.h>
    4343#include <ipc/services.h>
    44 #include <loc.h>
     44#include <ipc/devman.h>
     45#include <devman.h>
    4546#include <device/char_dev.h>
    4647#include <str.h>
    … …  
    7071                }
    7172       
    72         service_id_t svc_id;
    73         int res = loc_service_get_id("devices/\\hw\\pci0\\00:01.0\\com1\\a",
    74             &svc_id, IPC_FLAG_BLOCKING);
     73        devman_handle_t handle;
     74        int res = devman_fun_get_handle("/hw/pci0/00:01.0/com1/a", &handle,
     75            IPC_FLAG_BLOCKING);
    7576        if (res != EOK)
    76                 return "Failed getting serial port service ID";
    77        
    78         async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE, svc_id,
     77                return "Could not get serial device handle";
     78       
     79        async_sess_t *sess = devman_device_connect(EXCHANGE_SERIALIZE, handle,
    7980            IPC_FLAG_BLOCKING);
    8081        if (!sess)
    81                 return "Failed connecting to serial device";
     82                return "Unable to connect to serial device";
    8283       
    8384        char *buf = (char *) malloc(cnt + 1);
    8485        if (buf == NULL) {
    8586                async_hangup(sess);
    86                 return "Failed allocating input buffer";
     87                return "Failed to allocate input buffer";
    8788        }
    8889       
    … …  
    111112                free(buf);
    112113                async_hangup(sess);
    113                 return "Failed setting serial communication parameters";
    114         }
    115        
    116         TPRINTF("Trying reading %zu characters from serial device "
    117             "(svc_id=%" PRIun ")\n", cnt, svc_id);
     114                return "Failed to set serial communication parameters";
     115        }
     116       
     117        TPRINTF("Trying to read %zu characters from serial device "
     118            "(handle=%" PRIun ")\n", cnt, handle);
    118119       
    119120        size_t total = 0;
    … …  
    129130                        free(buf);
    130131                        async_hangup(sess);
    131                         return "Failed reading from serial device";
     132                        return "Failed read from serial device";
    132133                }
    133134               
    … …  
    164165                                free(buf);
    165166                                async_hangup(sess);
    166                                 return "Failed writing to serial device";
     167                                return "Failed write to serial device";
    167168                        }
    168169                       

  • uspace/app/websrv/websrv.c

    rd9f53877 r9d58539  
    200200{
    201201        if (str_cmp(uri, "/") == 0)
    202                 uri = "/index.html";
     202                uri = "/index.htm";
    203203       
    204204        char *fname;

  • uspace/drv/bus/isa/isa.c

    rd9f53877 r9d58539  
    6666#include <ops/hw_res.h>
    6767
     68#include <devman.h>
     69#include <ipc/devman.h>
    6870#include <device/hw_res.h>
    6971

  • uspace/drv/bus/usb/uhcirh/port.c

    rd9f53877 r9d58539  
    3737#include <str_error.h>
    3838#include <async.h>
     39#include <devman.h>
    3940
    4041#include <usb/usb.h>    /* usb_address_t */

  • uspace/drv/bus/usb/usbhub/port.c

    rd9f53877 r9d58539  
    3535
    3636#include <bool.h>
     37#include <devman.h>
    3738#include <errno.h>
    3839#include <str_error.h>

  • uspace/drv/char/ns8250/ns8250.c

    rd9f53877 r9d58539  
    7474#define DLAB_MASK (1 << 7)
    7575
    76 /** Interrupt Enable Register definition. */
    77 #define NS8250_IER_RXREADY      (1 << 0)
    78 #define NS8250_IER_THRE         (1 << 1)
    79 #define NS8250_IER_RXSTATUS     (1 << 2)
    80 #define NS8250_IER_MODEM_STATUS (1 << 3)
    81 
    82 /** Interrupt ID Register definition. */
    83 #define NS8250_IID_ACTIVE       (1 << 0)
    84 
    85 /** FIFO Control Register definition. */
    86 #define NS8250_FCR_FIFOENABLE   (1 << 0)
    87 #define NS8250_FCR_RXFIFORESET  (1 << 1)
    88 #define NS8250_FCR_TXFIFORESET  (1 << 2)
    89 #define NS8250_FCR_DMAMODE      (1 << 3)
    90 #define NS8250_FCR_RXTRIGGERLOW (1 << 6)
    91 #define NS8250_FCR_RXTRIGGERHI  (1 << 7)
    92 
    93 /** Line Control Register definition. */
    94 #define NS8250_LCR_STOPBITS     (1 << 2)
    95 #define NS8250_LCR_PARITY       (1 << 3)
    96 #define NS8250_LCR_SENDBREAK    (1 << 6)
    97 #define NS8250_LCR_DLAB         (1 << 7)
    98 
    99 /** Modem Control Register definition. */
    100 #define NS8250_MCR_DTR          (1 << 0)
    101 #define NS8250_MCR_RTS          (1 << 1)
    102 #define NS8250_MCR_OUT1         (1 << 2)
    103 #define NS8250_MCR_OUT2         (1 << 3)
    104 #define NS8250_MCR_LOOPBACK     (1 << 4)
    105 #define NS8250_MCR_ALL          (0x1f)
    106 
    107 /** Line Status Register definition. */
    108 #define NS8250_LSR_RXREADY      (1 << 0)
    109 #define NS8250_LSR_OE           (1 << 1)
    110 #define NS8250_LSR_PE           (1 << 2)
    111 #define NS8250_LSR_FE           (1 << 3)
    112 #define NS8250_LSR_BREAK        (1 << 4)
    113 #define NS8250_LSR_THRE         (1 << 5)
    114 #define NS8250_LSR_TSE          (1 << 6)
    115 
    116 /** Modem Status Register definition. */
    117 #define NS8250_MSR_DELTACTS     (1 << 0)
    118 #define NS8250_MSR_DELTADSR     (1 << 1)
    119 #define NS8250_MSR_RITRAILING   (1 << 2)
    120 #define NS8250_MSR_DELTADCD     (1 << 3)
    121 #define NS8250_MSR_CTS          (1 << 4)
    122 #define NS8250_MSR_DSR          (1 << 5)
    123 #define NS8250_MSR_RI           (1 << 6)
    124 #define NS8250_MSR_DCD          (1 << 7)
    125 #define NS8250_MSR_SIGNALS      (NS8250_MSR_CTS | NS8250_MSR_DSR \
    126     | NS8250_MSR_RI | NS8250_MSR_DCD)
    127 
    12876/** Obtain soft-state structure from function node */
    12977#define NS8250(fnode) ((ns8250_t *) ((fnode)->dev->driver_data))
    … …  
    14896} stop_bit_t;
    14997
    150 /** 8250 UART registers layout. */
    151 typedef struct {
    152         ioport8_t data;         /**< Data register. */
    153         ioport8_t ier;          /**< Interrupt Enable Reg. */
    154         ioport8_t iid;          /**< Interrupt ID Reg. */
    155         ioport8_t lcr;          /**< Line Control Reg. */
    156         ioport8_t mcr;          /**< Modem Control Reg. */
    157         ioport8_t lsr;          /**< Line Status Reg. */
    158         ioport8_t msr;          /**< Modem Status Reg. */
    159 } ns8250_regs_t;
    160 
    16198/** The driver data for the serial port devices. */
    16299typedef struct ns8250 {
    … …  
    165102        /** DDF function node */
    166103        ddf_fun_t *fun;
    167         /** I/O registers **/
    168         ns8250_regs_t *regs;
    169104        /** Is there any client conntected to the device? */
    170105        bool client_connected;
    … …  
    189124 *                      otherwise.
    190125 */
    191 static bool ns8250_received(ns8250_regs_t *regs)
    192 {
    193         return (pio_read_8(&regs->lsr) & NS8250_LSR_RXREADY) != 0;
     126static bool ns8250_received(ioport8_t *port)
     127{
     128        return (pio_read_8(port + 5) & 1) != 0;
    194129}
    195130
    … …  
    199134 * @return              The data read.
    200135 */
    201 static uint8_t ns8250_read_8(ns8250_regs_t *regs)
    202 {
    203         return pio_read_8(&regs->data);
     136static uint8_t ns8250_read_8(ioport8_t *port)
     137{
     138        return pio_read_8(port);
    204139}
    205140
    … …  
    208143 * @param port          The base address of the serial port device's ports.
    209144 */
    210 static bool is_transmit_empty(ns8250_regs_t *regs)
    211 {
    212         return (pio_read_8(&regs->lsr) & NS8250_LSR_THRE) != 0;
     145static bool is_transmit_empty(ioport8_t *port)
     146{
     147        return (pio_read_8(port + 5) & 0x20) != 0;
    213148}
    214149
    … …  
    218153 * @param c             The character to be written to the serial port device.
    219154 */
    220 static void ns8250_write_8(ns8250_regs_t *regs, uint8_t c)
    221 {
    222         while (!is_transmit_empty(regs))
     155static void ns8250_write_8(ioport8_t *port, uint8_t c)
     156{
     157        while (!is_transmit_empty(port))
    223158                ;
    224159       
    225         pio_write_8(&regs->data, c);
     160        pio_write_8(port, c);
    226161}
    227162
    … …  
    258193{
    259194        fibril_mutex_lock(&ns->mutex);
    260         ns8250_write_8(ns->regs, c);
     195        ns8250_write_8(ns->port, c);
    261196        fibril_mutex_unlock(&ns->mutex);
    262197}
    … …  
    277212                ns8250_putchar(ns, (uint8_t) buf[idx]);
    278213       
    279         return count;
     214        return 0;
    280215}
    281216
    … …  
    331266                return false;
    332267        }
    333 
    334         ns->regs = (ns8250_regs_t *)ns->port;
    335268       
    336269        return true;
    … …  
    346279        ddf_msg(LVL_DEBUG, "ns8250_dev_probe %s", ns->dev->name);
    347280       
     281        ioport8_t *port_addr = ns->port;
    348282        bool res = true;
    349283        uint8_t olddata;
    350284       
    351         olddata = pio_read_8(&ns->regs->mcr);
    352        
    353         pio_write_8(&ns->regs->mcr, NS8250_MCR_LOOPBACK);
    354         if (pio_read_8(&ns->regs->msr) & NS8250_MSR_SIGNALS)
     285        olddata = pio_read_8(port_addr + 4);
     286       
     287        pio_write_8(port_addr + 4, 0x10);
     288        if (pio_read_8(port_addr + 6) & 0xf0)
    355289                res = false;
    356290       
    357         pio_write_8(&ns->regs->mcr, NS8250_MCR_ALL);
    358         if ((pio_read_8(&ns->regs->msr) & NS8250_MSR_SIGNALS)
    359             != NS8250_MSR_SIGNALS)
     291        pio_write_8(port_addr + 4, 0x1f);
     292        if ((pio_read_8(port_addr + 6) & 0xf0) != 0xf0)
    360293                res = false;
    361294       
    362         pio_write_8(&ns->regs->mcr, olddata);
     295        pio_write_8(port_addr + 4, olddata);
    363296       
    364297        if (!res) {
    … …  
    457390 * @param port          The base address of the serial port device's ports.
    458391 */
    459 static inline void ns8250_port_interrupts_enable(ns8250_regs_t *regs)
    460 {
    461         /* Interrupt when data received. */
    462         pio_write_8(&regs->ier, NS8250_IER_RXREADY);
    463         pio_write_8(&regs->mcr, NS8250_MCR_DTR | NS8250_MCR_RTS
    464             | NS8250_MCR_OUT2);
     392static inline void ns8250_port_interrupts_enable(ioport8_t *port)
     393{
     394        pio_write_8(port + 1, 0x1);     /* Interrupt when data received. */
     395        pio_write_8(port + 4, 0xB);
    465396}
    466397
    … …  
    469400 * @param port          The base address of the serial port device's ports
    470401 */
    471 static inline void ns8250_port_interrupts_disable(ns8250_regs_t *regs)
    472 {
    473         pio_write_8(&regs->ier, 0x0);   /* Disable all interrupts. */
     402static inline void ns8250_port_interrupts_disable(ioport8_t *port)
     403{
     404        pio_write_8(port + 1, 0x0);     /* Disable all interrupts. */
    474405}
    475406
    … …  
    500431
    501432        /* Enable interrupt on the serial port. */
    502         ns8250_port_interrupts_enable(ns->regs);
     433        ns8250_port_interrupts_enable(ns->port);
    503434       
    504435        return EOK;
    … …  
    512443 * @param port          The base address of the serial port device's ports.
    513444 */
    514 static inline void enable_dlab(ns8250_regs_t *regs)
    515 {
    516         uint8_t val = pio_read_8(&regs->lcr);
    517         pio_write_8(&regs->lcr, val | NS8250_LCR_DLAB);
     445static inline void enable_dlab(ioport8_t *port)
     446{
     447        uint8_t val = pio_read_8(port + 3);
     448        pio_write_8(port + 3, val | DLAB_MASK);
    518449}
    519450
    … …  
    522453 * @param port          The base address of the serial port device's ports.
    523454 */
    524 static inline void clear_dlab(ns8250_regs_t *regs)
    525 {
    526         uint8_t val = pio_read_8(&regs->lcr);
    527         pio_write_8(&regs->lcr, val & (~NS8250_LCR_DLAB));
     455static inline void clear_dlab(ioport8_t *port)
     456{
     457        uint8_t val = pio_read_8(port + 3);
     458        pio_write_8(port + 3, val & (~DLAB_MASK));
    528459}
    529460
    … …  
    535466 *                      if the specified baud_rate is not valid).
    536467 */
    537 static int ns8250_port_set_baud_rate(ns8250_regs_t *regs, unsigned int baud_rate)
     468static int ns8250_port_set_baud_rate(ioport8_t *port, unsigned int baud_rate)
    538469{
    539470        uint16_t divisor;
    … …  
    551482       
    552483        /* Enable DLAB to be able to access baud rate divisor. */
    553         enable_dlab(regs);
     484        enable_dlab(port);
    554485       
    555486        /* Set divisor low byte. */
    556         pio_write_8(&regs->data, div_low);
     487        pio_write_8(port + 0, div_low);
    557488        /* Set divisor high byte. */
    558         pio_write_8(&regs->ier, div_high);
    559        
    560         clear_dlab(regs);
     489        pio_write_8(port + 1, div_high);
     490       
     491        clear_dlab(port);
    561492       
    562493        return EOK;
    … …  
    568499 * @param baud_rate     The ouput parameter to which the baud rate is stored.
    569500 */
    570 static unsigned int ns8250_port_get_baud_rate(ns8250_regs_t *regs)
     501static unsigned int ns8250_port_get_baud_rate(ioport8_t *port)
    571502{
    572503        uint16_t divisor;
    … …  
    574505       
    575506        /* Enable DLAB to be able to access baud rate divisor. */
    576         enable_dlab(regs);
     507        enable_dlab(port);
    577508       
    578509        /* Get divisor low byte. */
    579         div_low = pio_read_8(&regs->data);
     510        div_low = pio_read_8(port + 0);
    580511        /* Get divisor high byte. */
    581         div_high = pio_read_8(&regs->ier);
    582        
    583         clear_dlab(regs);
     512        div_high = pio_read_8(port + 1);
     513       
     514        clear_dlab(port);
    584515       
    585516        divisor = (div_high << 8) | div_low;
    … …  
    594525 * @param stop_bits     The number of stop bits used (one or two).
    595526 */
    596 static void ns8250_port_get_com_props(ns8250_regs_t *regs, unsigned int *parity,
     527static void ns8250_port_get_com_props(ioport8_t *port, unsigned int *parity,
    597528    unsigned int *word_length, unsigned int *stop_bits)
    598529{
    599530        uint8_t val;
    600531       
    601         val = pio_read_8(&regs->lcr);
    602         *parity = ((val >> NS8250_LCR_PARITY) & 7);
     532        val = pio_read_8(port + 3);
     533        *parity = ((val >> 3) & 7);
    603534       
    604535        switch (val & 3) {
    … …  
    617548        }
    618549       
    619         if ((val >> NS8250_LCR_STOPBITS) & 1)
     550        if ((val >> 2) & 1)
    620551                *stop_bits = 2;
    621552        else
    … …  
    631562 *                      is invalid.
    632563 */
    633 static int ns8250_port_set_com_props(ns8250_regs_t *regs, unsigned int parity,
     564static int ns8250_port_set_com_props(ioport8_t *port, unsigned int parity,
    634565    unsigned int word_length, unsigned int stop_bits)
    635566{
    … …  
    655586        switch (stop_bits) {
    656587        case 1:
    657                 val |= ONE_STOP_BIT << NS8250_LCR_STOPBITS;
     588                val |= ONE_STOP_BIT << 2;
    658589                break;
    659590        case 2:
    660                 val |= TWO_STOP_BITS << NS8250_LCR_STOPBITS;
     591                val |= TWO_STOP_BITS << 2;
    661592                break;
    662593        default:
    … …  
    670601        case SERIAL_MARK_PARITY:
    671602        case SERIAL_SPACE_PARITY:
    672                 val |= parity << NS8250_LCR_PARITY;
     603                val |= parity << 3;
    673604                break;
    674605        default:
    … …  
    676607        }
    677608       
    678         pio_write_8(&regs->lcr, val);
     609        pio_write_8(port + 3, val);
    679610       
    680611        return EOK;
    … …  
    689620static void ns8250_initialize_port(ns8250_t *ns)
    690621{
     622        ioport8_t *port = ns->port;
     623       
    691624        /* Disable interrupts. */
    692         ns8250_port_interrupts_disable(ns->regs);
     625        ns8250_port_interrupts_disable(port);
    693626        /* Set baud rate. */
    694         ns8250_port_set_baud_rate(ns->regs, 38400);
     627        ns8250_port_set_baud_rate(port, 38400);
    695628        /* 8 bits, no parity, two stop bits. */
    696         ns8250_port_set_com_props(ns->regs, SERIAL_NO_PARITY, 8, 2);
     629        ns8250_port_set_com_props(port, SERIAL_NO_PARITY, 8, 2);
    697630        /* Enable FIFO, clear them, with 14-byte threshold. */
    698         pio_write_8(&ns->regs->iid, NS8250_FCR_FIFOENABLE
    699             | NS8250_FCR_RXFIFORESET | NS8250_FCR_TXFIFORESET
    700             | NS8250_FCR_RXTRIGGERLOW | NS8250_FCR_RXTRIGGERHI);
     631        pio_write_8(port + 2, 0xC7);
    701632        /*
    702633         * RTS/DSR set (Request to Send and Data Terminal Ready lines enabled),
    703634         * Aux Output2 set - needed for interrupts.
    704635         */
    705         pio_write_8(&ns->regs->mcr, NS8250_MCR_DTR | NS8250_MCR_RTS
    706             | NS8250_MCR_OUT2);
     636        pio_write_8(port + 4, 0x0B);
    707637}
    708638
    … …  
    714644{
    715645        /* Disable FIFO */
    716         pio_write_8(&ns->regs->iid, 0x00);
     646        pio_write_8(ns->port + 2, 0x00);
    717647        /* Disable DTR, RTS, OUT1, OUT2 (int. enable) */
    718         pio_write_8(&ns->regs->mcr, 0x00);
     648        pio_write_8(ns->port + 4, 0x00);
    719649        /* Disable all interrupts from the port */
    720         ns8250_port_interrupts_disable(ns->regs);
     650        ns8250_port_interrupts_disable(ns->port);
    721651}
    722652
    … …  
    728658static void ns8250_read_from_device(ns8250_t *ns)
    729659{
    730         ns8250_regs_t *regs = ns->regs;
     660        ioport8_t *port = ns->port;
    731661        bool cont = true;
    732662       
    … …  
    734664                fibril_mutex_lock(&ns->mutex);
    735665               
    736                 cont = ns8250_received(regs);
     666                cont = ns8250_received(port);
    737667                if (cont) {
    738                         uint8_t val = ns8250_read_8(regs);
     668                        uint8_t val = ns8250_read_8(port);
    739669                       
    740670                        if (ns->client_connected) {
    … …  
    966896{
    967897        ns8250_t *data = (ns8250_t *) dev->driver_data;
    968         ns8250_regs_t *regs = data->regs;
     898        ioport8_t *port = data->port;
    969899       
    970900        fibril_mutex_lock(&data->mutex);
    971         ns8250_port_interrupts_disable(regs);
    972         *baud_rate = ns8250_port_get_baud_rate(regs);
    973         ns8250_port_get_com_props(regs, parity, word_length, stop_bits);
    974         ns8250_port_interrupts_enable(regs);
     901        ns8250_port_interrupts_disable(port);
     902        *baud_rate = ns8250_port_get_baud_rate(port);
     903        ns8250_port_get_com_props(port, parity, word_length, stop_bits);
     904        ns8250_port_interrupts_enable(port);
    975905        fibril_mutex_unlock(&data->mutex);
    976906       
    … …  
    997927       
    998928        ns8250_t *data = (ns8250_t *) dev->driver_data;
    999         ns8250_regs_t *regs = data->regs;
     929        ioport8_t *port = data->port;
    1000930        int ret;
    1001931       
    1002932        fibril_mutex_lock(&data->mutex);
    1003         ns8250_port_interrupts_disable(regs);
    1004         ret = ns8250_port_set_baud_rate(regs, baud_rate);
     933        ns8250_port_interrupts_disable(port);
     934        ret = ns8250_port_set_baud_rate(port, baud_rate);
    1005935        if (ret == EOK)
    1006                 ret = ns8250_port_set_com_props(regs, parity, word_length, stop_bits);
    1007         ns8250_port_interrupts_enable(regs);
     936                ret = ns8250_port_set_com_props(port, parity, word_length, stop_bits);
     937        ns8250_port_interrupts_enable(port);
    1008938        fibril_mutex_unlock(&data->mutex);
    1009939       

  • uspace/drv/char/ps2mouse/main.c

    rd9f53877 r9d58539  
    3535#include <libarch/inttypes.h>
    3636#include <ddf/driver.h>
     37#include <devman.h>
    3738#include <device/hw_res_parsed.h>
    3839#include <errno.h>

  • uspace/drv/char/xtkbd/main.c

    rd9f53877 r9d58539  
    3535#include <libarch/inttypes.h>
    3636#include <ddf/driver.h>
     37#include <devman.h>
    3738#include <device/hw_res_parsed.h>
    3839#include <errno.h>

  • uspace/drv/infrastructure/root/root.c

    rd9f53877 r9d58539  
    5353#include <ddf/driver.h>
    5454#include <ddf/log.h>
     55#include <devman.h>
     56#include <ipc/devman.h>
    5557
    5658#define NAME "root"

  • uspace/drv/infrastructure/rootpc/rootpc.c

    rd9f53877 r9d58539  
    4848#include <ddf/driver.h>
    4949#include <ddf/log.h>
     50#include <devman.h>
     51#include <ipc/devman.h>
    5052#include <ipc/dev_iface.h>
    5153#include <ops/hw_res.h>

  • uspace/drv/nic/e1k/e1k.c

    rd9f53877 r9d58539  
    4646#include <ddf/log.h>
    4747#include <ddf/interrupt.h>
     48#include <devman.h>
    4849#include <device/hw_res_parsed.h>
    4950#include <device/pci.h>

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

    rd9f53877 r9d58539  
    5858static async_sess_t *vfs_sess = NULL;
    5959
    60 /* Current (working) directory. */
    6160static FIBRIL_MUTEX_INITIALIZE(cwd_mutex);
     61
    6262static int cwd_fd = -1;
    6363static char *cwd_path = NULL;
    6464static size_t cwd_size = 0;
    65 
    66 /* Previous directory. */
    67 static FIBRIL_MUTEX_INITIALIZE(pwd_mutex);
    68 static int pwd_fd = -1;
    69 static char *pwd_path = NULL;
    70 static size_t pwd_size = 0;
    71 
    7265
    7366/** Start an async exchange on the VFS session.
    … …  
    758751        fibril_mutex_lock(&cwd_mutex);
    759752       
    760 
    761         fibril_mutex_lock(&pwd_mutex);
    762 
    763         if (pwd_fd >= 0)
    764                 close(pwd_fd);
    765 
    766 
    767         if (pwd_path)
    768                 free(pwd_path);
    769 
    770 
    771         pwd_fd = cwd_fd;
    772         pwd_path = cwd_path;
    773         pwd_size = cwd_size;
    774 
    775         fibril_mutex_unlock(&pwd_mutex);
    776 
     753        if (cwd_fd >= 0)
     754                close(cwd_fd);
     755       
     756       
     757        if (cwd_path)
     758                free(cwd_path);
     759       
    777760        cwd_fd = fd;
    778761        cwd_path = abs;
    … …  
    798781        fibril_mutex_unlock(&cwd_mutex);
    799782       
    800         return buf;
    801 }
    802 
    803 
    804 char *getprevwd(char *buf, size_t size)
    805 {
    806         if (size == 0)
    807                 return NULL;
    808 
    809         fibril_mutex_lock(&pwd_mutex);
    810 
    811         if ((pwd_size == 0) || (size < pwd_size + 1)) {
    812                 fibril_mutex_unlock(&pwd_mutex);
    813                 return NULL;
    814         }
    815 
    816         str_cpy(buf, size, pwd_path);
    817         fibril_mutex_unlock(&pwd_mutex);
    818 
    819783        return buf;
    820784}

  • uspace/lib/c/include/unistd.h

    rd9f53877 r9d58539  
    5858#define getpagesize()  (PAGE_SIZE)
    5959
    60 extern int dup2(int, int);
     60extern int dup2(int oldfd, int newfd);
    6161
    6262extern ssize_t write(int, const void *, size_t);
    … …  
    7373extern int unlink(const char *);
    7474
    75 extern char *getcwd(char *, size_t);
    76 extern char *getprevwd(char *, size_t);
     75extern char *getcwd(char *buf, size_t);
    7776extern int rmdir(const char *);
    7877extern int chdir(const char *);

  • uspace/lib/net/generic/net_remote.c

    rd9f53877 r9d58539  
    4040#include <malloc.h>
    4141#include <async.h>
     42#include <devman.h>
    4243#include <generic.h>
    4344#include <net/modules.h>

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

    rd9f53877 r9d58539  
    3333 * Implementations of DDF interfaces functions (actual implementation).
    3434 */
     35#include <ipc/devman.h>
    3536#include <devman.h>
    3637#include <async.h>

  • uspace/lib/usbvirt/src/ipc_dev.c

    rd9f53877 r9d58539  
    3838#include <assert.h>
    3939#include <async.h>
     40#include <devman.h>
    4041#include <usbvirt/device.h>
    4142#include <usbvirt/ipc.h>

  • uspace/lib/usbvirt/src/ipc_hc.c

    rd9f53877 r9d58539  
    3838#include <assert.h>
    3939#include <async.h>
     40#include <devman.h>
    4041#include <usbvirt/device.h>
    4142#include <usbvirt/ipc.h>
Note: See TracChangeset for help on using the changeset viewer.