Changeset ac31040 in mainline


Ignore:
Timestamp:
2012-09-04T19:48:22Z (12 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
78ca12b
Parents:
85f7369 (diff), 8ec4144 (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.
Message:

merge mainline changes

Files:
2 added
14 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    r85f7369 rac31040  
    457457! [(CONFIG_HID_IN=generic|CONFIG_HID_IN=serial)&PLATFORM=ia64&MACHINE=i460GX] CONFIG_NS16550 (y/n)
    458458
     459% Support for ARM926 on-chip UART
     460! [(CONFIG_HID_OUT=generic|CONFIG_HID_OUT=serial)&PLATFORM=arm32&MACHINE=integratorcp] CONFIG_ARM926_UART (y/n)
     461
    459462% Support for Samsung S3C24XX on-chip UART
    460463! [(CONFIG_HID_OUT=generic|CONFIG_HID_OUT=serial)&PLATFORM=arm32&MACHINE=gta02] CONFIG_S3C24XX_UART (y/n)
    … …  
    482485
    483486% Serial line input module
    484 ! [CONFIG_DSRLNIN=y|(PLATFORM=arm32&MACHINE=gta02)|(PLATFORM=ia64&MACHINE=i460GX&CONFIG_NS16550=y)|(PLATFORM=ia64&MACHINE=ski)|(PLATFORM=sparc64&PROCESSOR=sun4v)] CONFIG_SRLN (y)
     487! [CONFIG_DSRLNIN=y|(PLATFORM=arm32&MACHINE=gta02)|(PLATFORM=arm32&MACHINE=integratorcp&CONFIG_ARM926_UART=y)|(PLATFORM=ia64&MACHINE=i460GX&CONFIG_NS16550=y)|(PLATFORM=ia64&MACHINE=ski)|(PLATFORM=sparc64&PROCESSOR=sun4v)] CONFIG_SRLN (y)
    485488
    486489% EGA support

  • boot/arch/arm32/include/main.h

    r85f7369 rac31040  
    5252
    5353/** GXemul testarm serial console output register */
    54 #define TESTARM_SCONS_ADDR      0x10000000
     54#define TESTARM_SCONS_ADDR      0x10000000
    5555
    5656/** IntegratorCP serial console output register */
    57 #define ICP_SCONS_ADDR          0x16000000
     57#define ICP_SCONS_ADDR          0x16000000
    5858
    5959extern void bootstrap(void);

  • kernel/arch/arm32/src/mach/integratorcp/integratorcp.c

    r85f7369 rac31040  
    3838#include <console/chardev.h>
    3939#include <genarch/drivers/pl050/pl050.h>
     40#include <genarch/drivers/arm926_uart/arm926_uart.h>
    4041#include <genarch/kbrd/kbrd.h>
     42#include <genarch/srln/srln.h>
    4143#include <console/console.h>
    4244#include <sysinfo/sysinfo.h>
    … …  
    5355#include <print.h>
    5456
     57
    5558#define SDRAM_SIZE      (sdram[((*(uint32_t *)(ICP_CMCR+ICP_SDRAMCR_OFFSET) & ICP_SDRAM_MASK) >> 2)])
    56 static icp_hw_map_t icp_hw_map;
    57 static irq_t icp_timer_irq;
     59
     60static struct {
     61        icp_hw_map_t hw_map;
     62        irq_t timer_irq;
     63        arm926_uart_t uart;
     64} icp;
     65
     66
     67
    5868struct arm_machine_ops icp_machine_ops = {
    5969        icp_init,
    … …  
    7080
    7181static bool hw_map_init_called = false;
    72 static bool vga_init = false;
    7382uint32_t sdram[8] = {
    7483        16777216,       /* 16mb */
    … …  
    8998void icp_vga_init(void)
    9099{
    91         *(uint32_t*)((char *)(icp_hw_map.cmcr)+0x14) = 0xA05F0000;
    92         *(uint32_t*)((char *)(icp_hw_map.cmcr)+0x1C) = 0x12C11000;
    93         *(uint32_t*)icp_hw_map.vga = 0x3F1F3F9C;
    94         *(uint32_t*)((char *)(icp_hw_map.vga) + 0x4) = 0x080B61DF;
    95         *(uint32_t*)((char *)(icp_hw_map.vga) + 0x8) = 0x067F3800;
    96         *(uint32_t*)((char *)(icp_hw_map.vga) + 0x10) = ICP_FB;
    97         *(uint32_t *)((char *)(icp_hw_map.vga) + 0x1C) = 0x182B;
    98         *(uint32_t*)((char *)(icp_hw_map.cmcr)+0xC) = 0x33805000;
     100        *(uint32_t*)((char *)(icp.hw_map.cmcr)+0x14) = 0xA05F0000;
     101        *(uint32_t*)((char *)(icp.hw_map.cmcr)+0x1C) = 0x12C11000;
     102        *(uint32_t*)icp.hw_map.vga = 0x3F1F3F9C;
     103        *(uint32_t*)((char *)(icp.hw_map.vga) + 0x4) = 0x080B61DF;
     104        *(uint32_t*)((char *)(icp.hw_map.vga) + 0x8) = 0x067F3800;
     105        *(uint32_t*)((char *)(icp.hw_map.vga) + 0x10) = ICP_FB;
     106        *(uint32_t *)((char *)(icp.hw_map.vga) + 0x1C) = 0x182B;
     107        *(uint32_t*)((char *)(icp.hw_map.cmcr)+0xC) = 0x33805000;
    99108       
    100109}
    … …  
    103112static inline uint32_t icp_irqc_get_sources(void)
    104113{
    105         return *((uint32_t *) icp_hw_map.irqc);
     114        return *((uint32_t *) icp.hw_map.irqc);
    106115}
    107116
    … …  
    113122static inline void icp_irqc_mask(uint32_t irq)
    114123{
    115         *((uint32_t *) icp_hw_map.irqc_mask) = (1 << irq);
     124        *((uint32_t *) icp.hw_map.irqc_mask) = (1 << irq);
    116125}
    117126
    … …  
    123132static inline void icp_irqc_unmask(uint32_t irq)
    124133{
    125         *((uint32_t *) icp_hw_map.irqc_unmask) |= (1 << irq);
    126 }
    127 
    128 /** Initializes icp_hw_map. */
     134        *((uint32_t *) icp.hw_map.irqc_unmask) |= (1 << irq);
     135}
     136
     137/** Initializes icp.hw_map. */
    129138void icp_init(void)
    130139{
    131         icp_hw_map.uart = km_map(ICP_UART, PAGE_SIZE,
    132             PAGE_WRITE | PAGE_NOT_CACHEABLE);
    133         icp_hw_map.kbd_ctrl = km_map(ICP_KBD, PAGE_SIZE, PAGE_NOT_CACHEABLE);
    134         icp_hw_map.kbd_stat = icp_hw_map.kbd_ctrl + ICP_KBD_STAT;
    135         icp_hw_map.kbd_data = icp_hw_map.kbd_ctrl + ICP_KBD_DATA;
    136         icp_hw_map.kbd_intstat = icp_hw_map.kbd_ctrl + ICP_KBD_INTR_STAT;
    137         icp_hw_map.rtc = km_map(ICP_RTC, PAGE_SIZE,
    138             PAGE_WRITE | PAGE_NOT_CACHEABLE);
    139         icp_hw_map.rtc1_load = icp_hw_map.rtc + ICP_RTC1_LOAD_OFFSET;
    140         icp_hw_map.rtc1_read = icp_hw_map.rtc + ICP_RTC1_READ_OFFSET;
    141         icp_hw_map.rtc1_ctl = icp_hw_map.rtc + ICP_RTC1_CTL_OFFSET;
    142         icp_hw_map.rtc1_intrclr = icp_hw_map.rtc + ICP_RTC1_INTRCLR_OFFSET;
    143         icp_hw_map.rtc1_bgload = icp_hw_map.rtc + ICP_RTC1_BGLOAD_OFFSET;
    144         icp_hw_map.rtc1_intrstat = icp_hw_map.rtc + ICP_RTC1_INTRSTAT_OFFSET;
    145 
    146         icp_hw_map.irqc = km_map(ICP_IRQC, PAGE_SIZE,
    147             PAGE_WRITE | PAGE_NOT_CACHEABLE);
    148         icp_hw_map.irqc_mask = icp_hw_map.irqc + ICP_IRQC_MASK_OFFSET;
    149         icp_hw_map.irqc_unmask = icp_hw_map.irqc + ICP_IRQC_UNMASK_OFFSET;
    150         icp_hw_map.cmcr = km_map(ICP_CMCR, PAGE_SIZE,
    151             PAGE_WRITE | PAGE_NOT_CACHEABLE);
    152         icp_hw_map.sdramcr = icp_hw_map.cmcr + ICP_SDRAMCR_OFFSET;
    153         icp_hw_map.vga = km_map(ICP_VGA, PAGE_SIZE,
     140        icp.hw_map.uart = km_map(ICP_UART, PAGE_SIZE,
     141            PAGE_WRITE | PAGE_NOT_CACHEABLE);
     142        icp.hw_map.kbd_ctrl = km_map(ICP_KBD, PAGE_SIZE, PAGE_NOT_CACHEABLE);
     143        icp.hw_map.kbd_stat = icp.hw_map.kbd_ctrl + ICP_KBD_STAT;
     144        icp.hw_map.kbd_data = icp.hw_map.kbd_ctrl + ICP_KBD_DATA;
     145        icp.hw_map.kbd_intstat = icp.hw_map.kbd_ctrl + ICP_KBD_INTR_STAT;
     146        icp.hw_map.rtc = km_map(ICP_RTC, PAGE_SIZE,
     147            PAGE_WRITE | PAGE_NOT_CACHEABLE);
     148        icp.hw_map.rtc1_load = icp.hw_map.rtc + ICP_RTC1_LOAD_OFFSET;
     149        icp.hw_map.rtc1_read = icp.hw_map.rtc + ICP_RTC1_READ_OFFSET;
     150        icp.hw_map.rtc1_ctl = icp.hw_map.rtc + ICP_RTC1_CTL_OFFSET;
     151        icp.hw_map.rtc1_intrclr = icp.hw_map.rtc + ICP_RTC1_INTRCLR_OFFSET;
     152        icp.hw_map.rtc1_bgload = icp.hw_map.rtc + ICP_RTC1_BGLOAD_OFFSET;
     153        icp.hw_map.rtc1_intrstat = icp.hw_map.rtc + ICP_RTC1_INTRSTAT_OFFSET;
     154
     155        icp.hw_map.irqc = km_map(ICP_IRQC, PAGE_SIZE,
     156            PAGE_WRITE | PAGE_NOT_CACHEABLE);
     157        icp.hw_map.irqc_mask = icp.hw_map.irqc + ICP_IRQC_MASK_OFFSET;
     158        icp.hw_map.irqc_unmask = icp.hw_map.irqc + ICP_IRQC_UNMASK_OFFSET;
     159        icp.hw_map.cmcr = km_map(ICP_CMCR, PAGE_SIZE,
     160            PAGE_WRITE | PAGE_NOT_CACHEABLE);
     161        icp.hw_map.sdramcr = icp.hw_map.cmcr + ICP_SDRAMCR_OFFSET;
     162        icp.hw_map.vga = km_map(ICP_VGA, PAGE_SIZE,
    154163            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    155164
    … …  
    164173{
    165174        icp_irqc_mask(ICP_TIMER_IRQ);
    166         *((uint32_t*) icp_hw_map.rtc1_load) = frequency;
    167         *((uint32_t*) icp_hw_map.rtc1_bgload) = frequency;
    168         *((uint32_t*) icp_hw_map.rtc1_ctl) = ICP_RTC_CTL_VALUE;
     175        *((uint32_t*) icp.hw_map.rtc1_load) = frequency;
     176        *((uint32_t*) icp.hw_map.rtc1_bgload) = frequency;
     177        *((uint32_t*) icp.hw_map.rtc1_ctl) = ICP_RTC_CTL_VALUE;
    169178        icp_irqc_unmask(ICP_TIMER_IRQ);
    170179}
    … …  
    172181static irq_ownership_t icp_timer_claim(irq_t *irq)
    173182{
    174         if (icp_hw_map.rtc1_intrstat) {
    175                 *((uint32_t*) icp_hw_map.rtc1_intrclr) = 1;
     183        if (icp.hw_map.rtc1_intrstat) {
     184                *((uint32_t*) icp.hw_map.rtc1_intrclr) = 1;
    176185                return IRQ_ACCEPT;
    177186        } else
    … …  
    200209static void icp_timer_irq_init(void)
    201210{
    202         irq_initialize(&icp_timer_irq);
    203         icp_timer_irq.devno = device_assign_devno();
    204         icp_timer_irq.inr = ICP_TIMER_IRQ;
    205         icp_timer_irq.claim = icp_timer_claim;
    206         icp_timer_irq.handler = icp_timer_irq_handler;
    207 
    208         irq_register(&icp_timer_irq);
     211        irq_initialize(&icp.timer_irq);
     212        icp.timer_irq.devno = device_assign_devno();
     213        icp.timer_irq.inr = ICP_TIMER_IRQ;
     214        icp.timer_irq.claim = icp_timer_claim;
     215        icp.timer_irq.handler = icp_timer_irq_handler;
     216
     217        irq_register(&icp.timer_irq);
    209218}
    210219
    … …  
    231240
    232241        if (hw_map_init_called) {
    233                 *size = (sdram[((*(uint32_t *)icp_hw_map.sdramcr &
     242                *size = (sdram[((*(uint32_t *)icp.hw_map.sdramcr &
    234243                    ICP_SDRAM_MASK) >> 2)]);
    235244        } else {
    … …  
    286295{
    287296#ifdef CONFIG_FB
     297        static bool vga_init = false;
    288298        if (!vga_init) {
    289299                icp_vga_init();
    … …  
    304314                stdout_wire(fbdev);
    305315#endif
     316#ifdef CONFIG_ARM926_UART
     317        if (arm926_uart_init(&icp.uart, ARM926_UART0_IRQ,
     318            ARM926_UART0_BASE_ADDRESS, sizeof(arm926_uart_regs_t)))
     319                stdout_wire(&icp.uart.outdev);
     320#endif
    306321}
    307322
    … …  
    310325
    311326        pl050_t *pl050 = malloc(sizeof(pl050_t), FRAME_ATOMIC);
    312         pl050->status = (ioport8_t *)icp_hw_map.kbd_stat;
    313         pl050->data = (ioport8_t *)icp_hw_map.kbd_data;
    314         pl050->ctrl = (ioport8_t *)icp_hw_map.kbd_ctrl;
     327        pl050->status = (ioport8_t *)icp.hw_map.kbd_stat;
     328        pl050->data = (ioport8_t *)icp.hw_map.kbd_data;
     329        pl050->ctrl = (ioport8_t *)icp.hw_map.kbd_ctrl;
    315330               
    316331        pl050_instance_t *pl050_instance = pl050_init(pl050, ICP_KBD_IRQ);
    … …  
    335350            ICP_KBD);
    336351
     352#ifdef CONFIG_ARM926_UART
     353        srln_instance_t *srln_instance = srln_init();
     354        if (srln_instance) {
     355                indev_t *sink = stdin_wire();
     356                indev_t *srln = srln_wire(srln_instance, sink);
     357                arm926_uart_input_wire(&icp.uart, srln);
     358                icp_irqc_unmask(ARM926_UART0_IRQ);
     359        }
     360#endif
    337361}
    338362

  • kernel/genarch/Makefile.inc

    r85f7369 rac31040  
    9191endif
    9292
     93ifeq ($(CONFIG_ARM926_UART),y)
     94        GENARCH_SOURCES += \
     95                genarch/src/drivers/arm926_uart/arm926_uart.c
     96endif
     97
    9398ifeq ($(CONFIG_S3C24XX_IRQC),y)
    9499        GENARCH_SOURCES += \

  • uspace/lib/c/generic/tls.c

    r85f7369 rac31040  
    4242#include <str.h>
    4343#include <align.h>
     44#include <unistd.h>
    4445
    4546/** Create TLS (Thread Local Storage) data structures.
    … …  
    5758       
    5859        tcb = __alloc_tls(&data, tls_size);
     60        if (!tcb)
     61                return NULL;
    5962       
    6063        /*
    … …  
    8992
    9093        result = malloc(sizeof(tcb_t) + size);
     94        if (!result)
     95                return NULL;
    9196        *data = ((void *)result) + sizeof(tcb_t);
     97
    9298        return result;
    9399}
    … …  
    118124        size = ALIGN_UP(size, &_tls_alignment);
    119125        *data = memalign((uintptr_t) &_tls_alignment, sizeof(tcb_t) + size);
    120 
     126        if (!*data)
     127                return NULL;
    121128        tcb = (tcb_t *) (*data + size);
    122129        tcb->self = tcb;

  • uspace/srv/fs/udf/udf_cksum.c

    r85f7369 rac31040  
    7373};
    7474
    75 /** Calculate CRC16
    76  *
    77  */
    78 uint16_t udf_cksum(uint8_t *buf, size_t len)
    79 {
    80         uint16_t crc = 0;
    81        
    82         while (len-- > 0)
    83                 crc = crc_table[(crc >> 8 ^ *buf++) & 0xff] ^ (crc << 8);
    84        
    85         return crc;
    86 }
    87 
    8875/** Unicode checksum
    8976 *
    … …  
    10390       
    10491        return crc;
    105 }
    106 
    107 /** EA checksum
    108  *
    109  * Calculate a 16-bit checksum of the Implementation Use
    110  * Extended Attribute header or Application Use Extended Attribute
    111  * header. The fields AttributeType through ImplementationIdentifier
    112  * (or ApplicationIdentifier) inclusively represent the
    113  * data covered by the checksum (48 bytes).
    114  *
    115  */
    116 uint16_t udf_ea_cksum(uint8_t *data)
    117 {
    118         uint16_t checksum = 0;
    119         size_t count;
    120        
    121         for (count = 0; count < 48; count++)
    122                 checksum += *data++;
    123        
    124         return checksum;
    12592}
    12693

  • uspace/srv/fs/udf/udf_cksum.h

    r85f7369 rac31040  
    3939#define UDF_TAG_SIZE  16
    4040
    41 extern uint16_t udf_cksum(uint8_t *, size_t);
    4241extern uint16_t udf_unicode_cksum(uint16_t *, size_t);
    43 extern uint16_t udf_ea_cksum(uint8_t *);
    4442extern uint8_t udf_tag_checksum(uint8_t *);
    4543

  • uspace/srv/fs/udf/udf_file.c

    r85f7369 rac31040  
    5757 *
    5858 */
    59 int udf_read_extended_allocator(udf_node_t *node, uint16_t icb_flag,
     59static int udf_read_extended_allocator(udf_node_t *node, uint16_t icb_flag,
    6060    uint32_t pos)
    6161{
    … …  
    185185                         */
    186186                        if (FLE32(long_d->length) >> 30 == 3) {
    187                                 udf_read_extended_allocator (node, icb_flag, pos_long_ad);
     187                                udf_read_extended_allocator(node, icb_flag, pos_long_ad);
    188188                                break;
    189189                        }
    … …  
    296296}
    297297
    298 /** Read ICB sequence of allocators in Unallocated space entry descriptor
    299  *
    300  * This function read ICB sequence if free space is saved by space table.
    301  * Not finished.
    302  *
    303  * @param uased       Unallocated space entry descriptor
    304  * @param icb_flag    Type of allocators in sequence.
    305  *                    According to ECMA 167 4/14.8.8
    306  * @param start_alloc Offset of the allocator
    307  * @param len         Length of sequence
    308  *
    309  * @return EOK on success or a negative error code.
    310  *
    311  */
    312 int udf_read_free_space(uint8_t *uased, uint16_t icb_flag,
    313     uint32_t start_alloc, uint32_t len)
    314 {
    315         switch (icb_flag) {
    316         case UDF_SHORT_AD:
    317                 log_msg(LVL_DEBUG,
    318                     "UAICB: sequence of allocation descriptors - icbflag = short_ad_t");
    319                
    320                 /* Identify number of current partition */
    321                
    322                 size_t cnt = len / sizeof(udf_short_ad_t);
    323                 size_t n = 0;
    324                
    325                 while (n < cnt) {
    326                         udf_short_ad_t *short_d =
    327                             (udf_short_ad_t *) (uased + start_alloc + n * sizeof(udf_short_ad_t));
    328                        
    329                         if (short_d->length == 0)
    330                                 break;
    331                        
    332                         n++;
    333                 }
    334                
    335                 break;
    336                
    337         case UDF_LONG_AD:
    338                 log_msg(LVL_DEBUG,
    339                     "UAICB: sequence of allocation descriptors - icbflag = long_ad_t");
    340                
    341                 cnt = len / sizeof(udf_long_ad_t);
    342                 n = 0;
    343                
    344                 while (n < cnt) {
    345                         udf_long_ad_t *long_d =
    346                             (udf_long_ad_t *) (uased + start_alloc + n * sizeof(udf_long_ad_t));
    347                        
    348                         if (long_d->length == 0)
    349                                 break;
    350                        
    351                         n++;
    352                 }
    353                
    354                 break;
    355                
    356         case UDF_EXTENDED_AD:
    357                 log_msg(LVL_DEBUG,
    358                     "UAICB: sequence of allocation descriptors - icbflag = extended_ad_t");
    359                 break;
    360                
    361         case UDF_DATA_AD:
    362                 log_msg(LVL_DEBUG,
    363                     "UAICB: sequence of allocation descriptors - icbflag = 3, node contains data itself");
    364                 break;
    365         }
    366        
    367         return EOK;
    368 }
    369 
    370 /** Read Unallocated space entry descriptor
    371  *
    372  * Read ICB sequence if free space is saved by space table.
    373  * Not finished.
    374  *
    375  */
    376 int udf_read_unallocated_space_entry(udf_instance_t * instance, uint64_t pos,
    377     uint32_t len)
    378 {
    379         block_t *block = NULL;
    380         int rc = block_get(&block, instance->service_id, pos, BLOCK_FLAGS_NONE);
    381         if (rc != EOK)
    382                 return rc;
    383        
    384         udf_descriptor_tag_t *desc = (udf_descriptor_tag_t *) block->data;
    385         if (desc->checksum != udf_tag_checksum((uint8_t *) desc)) {
    386                 block_put(block);
    387                 return EINVAL;
    388         }
    389        
    390         if (FLE16(desc->id) != UDF_UASPACE_ENTRY) {
    391                 // FIXME: Memory leak
    392                 return EINVAL;
    393         }
    394        
    395         udf_unallocated_space_entry_descriptor_t *uased =
    396             (udf_unallocated_space_entry_descriptor_t *) block->data;
    397         if (uased->icbtag.file_type != UDF_ICBTYPE_UASE) {
    398                 // FIXME: Memory leak
    399                 return EINVAL;
    400         }
    401        
    402         uint16_t icb_flag = uased->icbtag.flags & UDF_ICBFLAG_MASK;
    403        
    404         rc = udf_read_free_space((uint8_t *) uased, icb_flag,
    405             UDF_UASE_OFFSET, uased->ad_lenght);
    406        
    407         return block_put(block);
    408 }
    409 
    410298/** Read data from disk - filling UDF node by allocators
    411299 *
    … …  
    419307        node->link_cnt = 1;
    420308        return udf_read_icb(node);
    421 }
    422 
    423 /** Read directory entry
    424  *
    425  * @param fid   Returned value
    426  * @param block Returned value
    427  * @param node  UDF node
    428  * @param pos   Number of FID which we need to find
    429  *
    430  * @return EOK on success or a negative error code.
    431  *
    432  */
    433 int udf_get_fid(udf_file_identifier_descriptor_t **fid, block_t **block,
    434     udf_node_t *node, aoff64_t pos)
    435 {
    436         if (node->data == NULL)
    437                 return udf_get_fid_in_allocator(fid, block, node, pos);
    438        
    439         return udf_get_fid_in_data(fid, node, pos);
    440309}
    441310
    … …  
    449318 *
    450319 */
    451 int udf_get_fid_in_data(udf_file_identifier_descriptor_t **fid,
     320static int udf_get_fid_in_data(udf_file_identifier_descriptor_t **fid,
    452321    udf_node_t *node, aoff64_t pos)
    453322{
    … …  
    488357       
    489358        return ENOENT;
     359}
     360
     361/** Read directory entry
     362 *
     363 * @param fid   Returned value
     364 * @param block Returned value
     365 * @param node  UDF node
     366 * @param pos   Number of FID which we need to find
     367 *
     368 * @return EOK on success or a negative error code.
     369 *
     370 */
     371int udf_get_fid(udf_file_identifier_descriptor_t **fid, block_t **block,
     372    udf_node_t *node, aoff64_t pos)
     373{
     374        if (node->data == NULL)
     375                return udf_get_fid_in_allocator(fid, block, node, pos);
     376       
     377        return udf_get_fid_in_data(fid, node, pos);
    490378}
    491379

  • uspace/srv/fs/udf/udf_file.h

    r85f7369 rac31040  
    197197extern int udf_read_allocation_sequence(udf_node_t *, uint8_t *, uint16_t,
    198198    uint32_t, uint32_t);
    199 extern int udf_read_extended_allocator(udf_node_t *, uint16_t, uint32_t);
    200199extern int udf_read_file(size_t *, ipc_callid_t, udf_node_t *, aoff64_t,
    201200    size_t);
    202201extern int udf_get_fid(udf_file_identifier_descriptor_t **, block_t **,
    203     udf_node_t *, aoff64_t);
    204 extern int udf_get_fid_in_data(udf_file_identifier_descriptor_t **,
    205202    udf_node_t *, aoff64_t);
    206203extern int udf_get_fid_in_allocator(udf_file_identifier_descriptor_t **,
    … …  
    208205extern int udf_get_fid_in_sector(udf_file_identifier_descriptor_t **,
    209206    block_t **, udf_node_t *, aoff64_t, size_t *, void **, size_t *);
    210 extern int udf_read_free_space(uint8_t *, uint16_t, uint32_t, uint32_t);
    211 extern int udf_read_unallocated_space_entry(udf_instance_t *, uint64_t,
    212     uint32_t);
    213207
    214208#endif /* UDF_FILE_H_ */

  • uspace/srv/fs/udf/udf_osta.c

    r85f7369 rac31040  
    9696 *
    9797 */
    98 size_t udf_uncompress_unicode(size_t number_of_bytes, uint8_t *udf_compressed,
    99     uint16_t *unicode, size_t unicode_max_len)
     98static size_t udf_uncompress_unicode(size_t number_of_bytes,
     99    uint8_t *udf_compressed, uint16_t *unicode, size_t unicode_max_len)
    100100{
    101101        /* Use udf_compressed to store current byte being read. */
    … …  
    129129       
    130130        return unicode_idx;
    131 }
    132 
    133 /** Convert Unicode wide characters to OSTA CS0 compressed Unicode string.
    134  *
    135  * The Unicode MUST be in the byte order of the compiler in order
    136  * to obtain correct results. Returns an error if the compression ID
    137  * is invalid.
    138  *
    139  * NOTE: This routine assumes the implementation already knows,
    140  * by the local environment, how many bits are appropriate and therefore
    141  * does no checking to test if the input characters fit into that number
    142  * of bits or not.
    143  *
    144  * @param[in]  number_of_chars Number of unicode characters.
    145  * @param[in]  comp_id         Compression ID to be used.
    146  * @param[in]  unicode         Unicode characters to compress.
    147  * @param[out] udf_compressed  Compressed string, as bytes.
    148  *
    149  * @return The total number of bytes in the compressed OSTA CS0 string,
    150  *         including the compression ID.
    151  *
    152  */
    153 size_t udf_compress_unicode(size_t number_of_chars, uint8_t comp_id,
    154     uint16_t *unicode, uint8_t *udf_compressed)
    155 {
    156         if ((comp_id != 8) && (comp_id != 16))
    157                 return 0;
    158        
    159         /* Place compression code in first byte. */
    160         udf_compressed[0] = comp_id;
    161        
    162         size_t byte_idx = 1;
    163         size_t unicode_idx = 0;
    164        
    165         while (unicode_idx < number_of_chars) {
    166                 if (comp_id == 16) {
    167                         /*
    168                          * First, place the high bits of the char
    169                          * into the byte stream.
    170                          */
    171                         udf_compressed[byte_idx++] =
    172                             (unicode[unicode_idx] & 0xFF00) >> 8;
    173                 }
    174                
    175                 /* Then place the low bits into the stream. */
    176                 udf_compressed[byte_idx++] = unicode[unicode_idx] & 0x00FF;
    177                 unicode_idx++;
    178         }
    179        
    180         return byte_idx;
    181131}
    182132

  • uspace/srv/fs/udf/udf_osta.h

    r85f7369 rac31040  
    5252#define PERIOD             0x002E
    5353
    54 extern size_t udf_uncompress_unicode(size_t, uint8_t *, uint16_t *, size_t);
    55 extern size_t udf_compress_unicode(size_t, uint8_t, uint16_t *, uint8_t *);
    5654extern size_t udf_translate_name(uint16_t *, uint16_t *, size_t);
    5755extern void udf_to_unix_name(char *, size_t, char *, size_t, udf_charspec_t *);

  • uspace/srv/fs/udf/udf_types.h

    r85f7369 rac31040  
    142142} __attribute__((packed)) udf_unallocated_space_descriptor_t;
    143143
    144 extern void udf_prepare_tag(udf_descriptor_tag_t *);
    145 
    146144#endif
    147145

  • uspace/srv/fs/udf/udf_volume.c

    r85f7369 rac31040  
    151151 *
    152152 */
    153 void udf_prepare_tag(udf_descriptor_tag_t *tag)
     153static void udf_prepare_tag(udf_descriptor_tag_t *tag)
    154154{
    155155        GET_LE16(tag->id);
    … …  
    159159        GET_LE16(tag->descriptor_crc_length);
    160160        GET_LE32(tag->location);
     161}
     162
     163/** Read AVD by using one of default sector size from array
     164 *
     165 * @param service_id
     166 * @param avd         Returned value - Anchor Volume Descriptor
     167 * @param sector_size Expected sector size
     168 *
     169 * @return EOK on success or a negative error code.
     170 *
     171 */
     172static int udf_get_anchor_volume_descriptor_by_ssize(service_id_t service_id,
     173    udf_anchor_volume_descriptor_t *avd, uint32_t sector_size)
     174{
     175        int rc = block_read_bytes_direct(service_id,
     176            UDF_AVDP_SECTOR * sector_size,
     177            sizeof(udf_anchor_volume_descriptor_t), avd);
     178        if (rc != EOK)
     179                return rc;
     180       
     181        if (avd->tag.checksum != udf_tag_checksum((uint8_t *) &avd->tag))
     182                return EINVAL;
     183       
     184        // TODO: Should be tested in big-endian mode
     185        udf_prepare_tag(&avd->tag);
     186       
     187        if (avd->tag.id != UDF_TAG_AVDP)
     188                return EINVAL;
     189       
     190        GET_LE32(avd->main_extent.length);
     191        GET_LE32(avd->main_extent.location);
     192        GET_LE32(avd->reserve_extent.length);
     193        GET_LE32(avd->reserve_extent.location);
     194       
     195        return EOK;
    161196}
    162197
    … …  
    200235       
    201236        return EINVAL;
    202 }
    203 
    204 /** Read AVD by using one of default sector size from array
    205  *
    206  * @param service_id
    207  * @param avd         Returned value - Anchor Volume Descriptor
    208  * @param sector_size Expected sector size
    209  *
    210  * @return EOK on success or a negative error code.
    211  *
    212  */
    213 int udf_get_anchor_volume_descriptor_by_ssize(service_id_t service_id,
    214     udf_anchor_volume_descriptor_t *avd, uint32_t sector_size)
    215 {
    216         int rc = block_read_bytes_direct(service_id,
    217             UDF_AVDP_SECTOR * sector_size,
    218             sizeof(udf_anchor_volume_descriptor_t), avd);
    219         if (rc != EOK)
    220                 return rc;
    221        
    222         if (avd->tag.checksum != udf_tag_checksum((uint8_t *) &avd->tag))
    223                 return EINVAL;
    224        
    225         // TODO: Should be tested in BegEndian mode
    226         udf_prepare_tag(&avd->tag);
    227        
    228         if (avd->tag.id != UDF_TAG_AVDP)
    229                 return EINVAL;
    230        
    231         GET_LE32(avd->main_extent.length);
    232         GET_LE32(avd->main_extent.location);
    233         GET_LE32(avd->reserve_extent.length);
    234         GET_LE32(avd->reserve_extent.location);
    235        
    236         return EOK;
    237237}
    238238

  • uspace/srv/fs/udf/udf_volume.h

    r85f7369 rac31040  
    215215extern int udf_get_anchor_volume_descriptor(service_id_t,
    216216    udf_anchor_volume_descriptor_t *);
    217 extern int udf_get_anchor_volume_descriptor_by_ssize(service_id_t,
    218     udf_anchor_volume_descriptor_t *, uint32_t);
    219217extern int udf_read_volume_descriptor_sequence(service_id_t, udf_extent_t);
    220218extern fs_index_t udf_long_ad_to_pos(udf_instance_t *, udf_long_ad_t *);
Note: See TracChangeset for help on using the changeset viewer.