uint32_t nfc_init ( /* [IN] the NAND flash information */ IO_NANDFLASH_STRUCT_PTR nandflash_ptr ) { /* Body */ uint32_t result = NANDFLASHERR_NO_ERROR; NFC_MemMapPtr nfc_ptr; uint32_t nand_id, block_size_kB, density, num_ecc_bytes; NANDFLASH_INFO_STRUCT_PTR nand_info_ptr; /* Initialize NFC I/O Pins */ nfc_io_init(); /* Get the pointer to nfc registers structure */ nfc_ptr = _bsp_get_nfc_address(); /* Create NANDFLASH_INFO_STRUCT based on NAND ID read from the NAND Flash, if not defined before manually */ if((nandflash_ptr->NANDFLASH_INFO_PTR) == NULL) { nand_info_ptr = (NANDFLASH_INFO_STRUCT_PTR)_mem_alloc_system_zero( (_mem_size)sizeof(NANDFLASH_INFO_STRUCT)); #if MQX_CHECK_MEMORY_ALLOCATION_ERRORS if(nand_info_ptr == NULL) { return((uint32_t)MQX_OUT_OF_MEMORY); } /* Endif */ #endif if (((*nandflash_ptr->IOCTL)(nandflash_ptr,NANDFLASH_IOCTL_GET_ID,&nand_id)) == NANDFLASHERR_NO_ERROR) { nand_info_ptr->PHY_PAGE_SIZE = (_mem_size)(((nand_id & NANDFLASH_ID_PAGE_SIZE_MASK) + 1)*1024); if((nand_id & NANDFLASH_ID_SPARE_BYTES_NUM_MASK)>>2 == 1) { nand_info_ptr->SPARE_AREA_SIZE = (_mem_size)64; } if(nand_id & NANDFLASH_ID_BLOCK_SIZE_MASK) { nand_info_ptr->BLOCK_SIZE = (_mem_size)((nand_id & NANDFLASH_ID_BLOCK_SIZE_MASK)*8192); } else { nand_info_ptr->BLOCK_SIZE = 65536; } block_size_kB = (nand_info_ptr->BLOCK_SIZE)/1024; density = (nand_id & NANDFLASH_ID_DENSITY_MASK)>>16; switch(density) { case NANDFLASH_DENSITY_1Gb: /* nand_info_ptr->NUM_BLOCKS = 1024/8*1024/block_size_kB; */ nand_info_ptr->NUM_BLOCKS = 131072/block_size_kB; break; case NANDFLASH_DENSITY_2Gb: nand_info_ptr->NUM_BLOCKS = 2*131072/block_size_kB; break; case NANDFLASH_DENSITY_4Gb: nand_info_ptr->NUM_BLOCKS = 4*131072/block_size_kB; break; case NANDFLASH_DENSITY_8Gb: nand_info_ptr->NUM_BLOCKS = 8*131072/block_size_kB; break; case NANDFLASH_DENSITY_16Gb: nand_info_ptr->NUM_BLOCKS = 16*131072/block_size_kB; break; default: break; } nand_info_ptr->WIDTH = (_mqx_uint)(8 + ((nand_id & NANDFLASH_ID_WIDTH_MASK)>>3)); nandflash_ptr->NANDFLASH_INFO_PTR = nand_info_ptr; nandflash_ptr->NUM_VIRTUAL_PAGES = ((nand_info_ptr->BLOCK_SIZE)/(nandflash_ptr->VIRTUAL_PAGE_SIZE))*(nand_info_ptr->NUM_BLOCKS); nandflash_ptr->PHY_PAGE_SIZE_TO_VIRTUAL_PAGE_SIZE_RATIO = (nand_info_ptr->PHY_PAGE_SIZE)/(nandflash_ptr->VIRTUAL_PAGE_SIZE); }
uint_32 _kusb_dcd_polled_init ( /* [IN] Initialization information for the device being opened */ KUSB_DCD_INIT_STRUCT_PTR io_init_ptr, /* [OUT] Address to store device specific information */ pointer _PTR_ io_info_ptr_ptr, /* [IN] The rest of the name of the device opened */ char_ptr open_name_ptr ) { /* Body */ USBDCD_MemMapPtr usb_dcd_ptr; KUSB_DCD_INFO_STRUCT_PTR io_info_ptr; SIM_MemMapPtr sim = SIM_BASE_PTR; USB_MemMapPtr usbotg = USB0_BASE_PTR; usb_dcd_ptr = _bsp_get_usb_dcd_base_address(); if (NULL == usb_dcd_ptr) { return USB_DCD_ERROR_CHANNEL_INVALID; } io_info_ptr = (KUSB_DCD_INFO_STRUCT_PTR)_mem_alloc_system_zero ((uint_32)sizeof (KUSB_DCD_INFO_STRUCT)); if (NULL == io_info_ptr) { return MQX_OUT_OF_MEMORY; } _mem_set_type (io_info_ptr, MEM_TYPE_IO_USB_DCD_INFO_STRUCT); *io_info_ptr_ptr = io_info_ptr; io_info_ptr->INIT = *io_init_ptr; io_info_ptr->USB_DCD_PTR = usb_dcd_ptr; io_info_ptr->METHOD = USB_DCD_POLLED; io_info_ptr->STATE = USB_DCD_DISABLE; /* USB DCD board specific initialization */ /* USB Clock Gating for OTG */ #ifdef BSP_TWRMCF51JF sim->SCGC6 |= SIM_SCGC6_USBOTG_MASK; #elif BSP_TWR_K70F120M || BSP_TWR_K60F120M sim->SCGC4 |= SIM_SCGC4_USBFS_MASK; #else sim->SCGC4 |= SIM_SCGC4_USBOTG_MASK; #endif /* USB Clock Gating for DCD */ sim->SCGC6 |= SIM_SCGC6_USBDCD_MASK; /* USB pre-initialization */ usbotg->USBTRC0 |= USB_USBTRC0_USBRESET_MASK; while (usbotg->USBTRC0 & USB_USBTRC0_USBRESET_MASK){}; usbotg->ISTAT |= USB_ISTAT_USBRST_MASK; /* USB DCD initialization */ /* CLOCK SPEED (in Khz)*/ if (io_init_ptr->CLOCK_SPEED < 0x400) /*Khz*/ { if (io_init_ptr->CLOCK_SPEED < 0x04) return USB_DCD_CLOCK_SPEED_INVALID; usb_dcd_ptr->CLOCK = ((uint_32)((uint_32)io_init_ptr->CLOCK_SPEED << USBDCD_CLOCK_CLOCK_SPEED_SHIFT)) & USBDCD_CLOCK_CLOCK_SPEED_MASK; } else { if (((uint_32)(io_init_ptr->CLOCK_SPEED/1000)) > 0x3FF) return USB_DCD_CLOCK_SPEED_INVALID; usb_dcd_ptr->CLOCK = (((uint_32)(((uint_32)(io_init_ptr->CLOCK_SPEED/1000)) << USBDCD_CLOCK_CLOCK_SPEED_SHIFT)) & USBDCD_CLOCK_CLOCK_SPEED_MASK) | USBDCD_CLOCK_CLOCK_UNIT_MASK; } /* Timer0 initialization */ usb_dcd_ptr->TIMER0 = (uint_32)((uint_32)(io_init_ptr->TSEQ_INIT)<<USBDCD_TIMER0_TSEQ_INIT_SHIFT) & USBDCD_TIMER0_TSEQ_INIT_MASK; /* Timer1 initialization */ usb_dcd_ptr->TIMER1 = ((uint_32)((uint_32)(io_init_ptr->TDCD_DBNC)<<USBDCD_TIMER1_TDCD_DBNC_SHIFT) & USBDCD_TIMER1_TDCD_DBNC_MASK) | ((uint_32)((uint_32)(io_init_ptr->TVDPSRC_ON)<<USBDCD_TIMER1_TVDPSRC_ON_SHIFT) & USBDCD_TIMER1_TVDPSRC_ON_MASK); /* Timer2 initialization */ usb_dcd_ptr->TIMER2 = ((uint_32)((uint_32)(io_init_ptr->TVDPSRC_CON)<<USBDCD_TIMER2_TVDPSRC_CON_SHIFT) & USBDCD_TIMER2_TVDPSRC_CON_MASK) | ((uint_32)((uint_32)(io_init_ptr->CHECK_DM)<<USBDCD_TIMER2_CHECK_DM_SHIFT) & USBDCD_TIMER2_CHECK_DM_MASK); /* Disable USB DCD module */ usb_dcd_ptr->CONTROL = USBDCD_CONTROL_IACK_MASK | USBDCD_CONTROL_SR_MASK; return USB_DCD_OK; } /* Endbody */
uint_32 ENET_initialize_ex ( /* [IN] optional parameters */ const ENET_PARAM_STRUCT * param_ptr, /* [IN] the local Ethernet address */ _enet_address address, /* [OUT] the Ethernet state structure */ _enet_handle _PTR_ handle ) { ENET_CONTEXT_STRUCT_PTR enet_ptr = NULL;//, other_enet_ptr; uint_32 result; boolean vlan; if (param_ptr == NULL) return ENETERR_INVALID_DEVICE; if (param_ptr->NUM_RX_BUFFERS < param_ptr->NUM_RX_ENTRIES) return ENETERR_INVALID_INIT_PARAM; enet_ptr = _mqx_get_io_component_handle(IO_ENET_COMPONENT); while (enet_ptr) { if (enet_ptr->PARAM_PTR->ENET_IF->MAC_NUMBER == param_ptr->ENET_IF->MAC_NUMBER) break; enet_ptr = enet_ptr->NEXT; } if (enet_ptr) { *handle = enet_ptr; return ENETERR_INITIALIZED_DEVICE; } else *handle = NULL; // Allocate the Enet context structure enet_ptr = _mem_alloc_system_zero(sizeof(ENET_CONTEXT_STRUCT)); if (NULL==enet_ptr) return ENETERR_ALLOC_CFG; _mem_set_type((pointer)enet_ptr, MEM_TYPE_IO_ENET_CONTEXT_STRUCT); // Initialize the Enet context structure eaddrcpy(enet_ptr->ADDRESS, address); enet_ptr->PARAM_PTR = param_ptr; vlan = (enet_ptr->PARAM_PTR->OPTIONS & ENET_OPTION_VLAN) == ENET_OPTION_VLAN; enet_ptr->MaxTxFrameSize = ENET_max_framesize(enet_ptr->PARAM_PTR->TX_BUFFER_SIZE,0,vlan); enet_ptr->MaxRxFrameSize = ENET_max_framesize(enet_ptr->PARAM_PTR->RX_BUFFER_SIZE,enet_ptr->PARAM_PTR->NUM_LARGE_BUFFERS,vlan); _lwsem_create(&enet_ptr->CONTEXT_LOCK, 1); // Initialize the MAC result = (*param_ptr->ENET_IF->MAC_IF->INIT)(enet_ptr); if (ENET_OK == result) { // Link the driver into the kernel component list _mqx_link_io_component_handle(IO_ENET_COMPONENT,enet_ptr, (pointer *)&enet_ptr->NEXT); *handle = enet_ptr; } else { _mem_free(enet_ptr); *handle = NULL; } return result; }
_mqx_int gpio_cpu_open ( /* [IN] the file handle for the device */ MQX_FILE_PTR fd_ptr, /* [IN] the file name */ char_ptr file_name, /* [IN] pointer to parameters */ char_ptr param_ptr ) { /* Body */ _mqx_int i; GPIO_DEV_DATA_PTR dev_data_ptr = (GPIO_DEV_DATA_PTR) fd_ptr->DEV_DATA_PTR; /* if file_name is used, then the user wants to open peripheral */ if ((file_name != NULL) && (*file_name != 0)) { if (!strncmp(file_name, "gpio:write", 11)) /* user wants write access to GPIO */ dev_data_ptr->type = DEV_OUTPUT; else if (!strncmp(file_name, "gpio:output", 12)) /* user wants write access to GPIO */ dev_data_ptr->type = DEV_OUTPUT; else if (!strncmp(file_name, "gpio:read", 10)) /* user wants read access to GPIO */ dev_data_ptr->type = DEV_INPUT; else if (!strncmp(file_name, "gpio:input", 11)) /* user wants read access to GPIO */ dev_data_ptr->type = DEV_INPUT; else /* peripherals not used yet */ return IO_ERROR; } else return IO_ERROR; /* check which irq pin to be opened and prepare interrupt service routine */ for (i = 1; i < 8; i++) { if ((i & 0x01) == 0) continue; if ((dev_data_ptr->irqp_map.reg.portnq | dev_data_ptr->irqn_map.reg.portnq) & (1 << i)) { if (MQX_init_struct.MQX_HARDWARE_INTERRUPT_LEVEL_MAX < i) return IO_ERROR; /* hardware level must be higher than interrupt level */ if (NULL == _int_install_isr(MCF5225_INT_EPORT0_EPF1 - 1 + i, gpio_eport_irq, NULL)) return IO_ERROR; /* could not install interrupt routine */ /* this is only to enable the interrupt source, level and sublevel values are hardwired */ _mcf5225_int_init(MCF5225_INT_EPORT0_EPF1 - 1 + i, i, BSP_EPORT_EPFX_INT_SUBLEVEL_MIDPOINT, TRUE); } } if ((param_ptr != NULL) && (dev_data_ptr->type == DEV_OUTPUT)) { /* set pins status before selecting GPIO function */ /* note that this is similar to GPIO_IOCTL_WRITE function, but no checking is performed (was done in io_gpio_open function) */ GPIO_PIN_STRUCT _PTR_ pin_table; uint_32 addr; uint_8 pin; GPIO_PIN_MAP_PTR temp_pin0_map_ptr; GPIO_PIN_MAP_PTR temp_pin1_map_ptr; if (NULL == (temp_pin0_map_ptr = (GPIO_PIN_MAP_PTR) _mem_alloc_system_zero(sizeof(GPIO_PIN_MAP)))) return IO_ERROR; if (NULL == (temp_pin1_map_ptr = (GPIO_PIN_MAP_PTR) _mem_alloc_system_zero(sizeof(GPIO_PIN_MAP)))) { _mem_free(temp_pin0_map_ptr); return IO_ERROR; } /* prepare pin map */ for (pin_table = (GPIO_PIN_STRUCT _PTR_) param_ptr; *pin_table != GPIO_LIST_END; pin_table++) { addr = (*pin_table & GPIO_PIN_ADDR) >> 3; /* prepare address of port */ pin = 1 << (*pin_table & 0x07); /* prepare bit mask */ if (*pin_table & GPIO_PIN_STATUS) temp_pin1_map_ptr->memory8[addr] |= pin; else temp_pin0_map_ptr->memory8[addr] |= pin; } /* ok, now we can apply new map */ /* note: applying the map after collecting pins is due to have pins applied in one instruction */ * (((uint_32 _PTR_) (&mcf5225_gpio_ptr->PORTTEP_SETTE)) + 0) = temp_pin1_map_ptr->memory32[0]; * (((uint_32 _PTR_) (&mcf5225_gpio_ptr->CLRTE)) + 0) = ~temp_pin0_map_ptr->memory32[0]; * (((uint_32 _PTR_) (&mcf5225_gpio_ptr->PORTTEP_SETTE)) + 1) = temp_pin1_map_ptr->memory32[1]; * (((uint_32 _PTR_) (&mcf5225_gpio_ptr->CLRTE)) + 1) = ~temp_pin0_map_ptr->memory32[1]; * (((uint_32 _PTR_) (&mcf5225_gpio_ptr->PORTTEP_SETTE)) + 2) = temp_pin1_map_ptr->memory32[2]; * (((uint_32 _PTR_) (&mcf5225_gpio_ptr->CLRTE)) + 2) = ~temp_pin0_map_ptr->memory32[2]; * (((uint_32 _PTR_) (&mcf5225_gpio_ptr->PORTTEP_SETTE)) + 3) = temp_pin1_map_ptr->memory32[3]; * (((uint_32 _PTR_) (&mcf5225_gpio_ptr->CLRTE)) + 3) = ~temp_pin0_map_ptr->memory32[3]; * (((uint_32 _PTR_) (&mcf5225_gpio_ptr->PORTTEP_SETTE)) + 4) = temp_pin1_map_ptr->memory32[4]; * (((uint_32 _PTR_) (&mcf5225_gpio_ptr->CLRTE)) + 4) = ~temp_pin0_map_ptr->memory32[4]; * (((uint_32 _PTR_) (&mcf5225_gpio_ptr->PORTTEP_SETTE)) + 5) = temp_pin1_map_ptr->memory32[5]; * (((uint_32 _PTR_) (&mcf5225_gpio_ptr->CLRTE)) + 5) = ~temp_pin0_map_ptr->memory32[5]; _mem_free(temp_pin1_map_ptr); _mem_free(temp_pin0_map_ptr); }
_mqx_int _io_pipe_open ( /* [IN] the file handle for the device being opened */ FILE_DEVICE_STRUCT_PTR fd_ptr, /* [IN] the remaining portion of the name of the device */ char *open_name_ptr, /* [IN] the flags to be used during operation: ** echo, translation, xon/xoff */ char *flags ) { /* Body */ IO_DEVICE_STRUCT_PTR io_dev_ptr = fd_ptr->DEV_PTR; IO_PIPE_INIT_STRUCT_PTR io_pipe_init_ptr; IO_PIPE_INFO_STRUCT_PTR io_pipe_info_ptr; MUTEX_ATTR_STRUCT mutex_attr; uint32_t result = MQX_OK; /* Allocate a Pipe information structure */ io_pipe_info_ptr = _mem_alloc_system_zero( (uint32_t)sizeof(IO_PIPE_INFO_STRUCT)); #if MQX_CHECK_MEMORY_ALLOCATION_ERRORS if (io_pipe_info_ptr == NULL){ return(MQX_OUT_OF_MEMORY); }/* Endif */ #endif fd_ptr->DEV_DATA_PTR = io_pipe_info_ptr; io_pipe_init_ptr = (IO_PIPE_INIT_STRUCT_PTR)io_dev_ptr->DRIVER_INIT_PTR; io_pipe_info_ptr->QUEUE_SIZE = io_pipe_init_ptr->QUEUE_SIZE; /* Initialize mutexes */ result = _mutatr_init(&mutex_attr); #if MQX_CHECK_ERRORS if (result != MQX_EOK) { _mem_free(io_pipe_info_ptr); return (result); } /* Endif */ #endif _mutatr_set_wait_protocol(&mutex_attr, MUTEX_PRIORITY_QUEUEING); _mutatr_set_sched_protocol(&mutex_attr, MUTEX_PRIO_INHERIT); result = _mutex_init(&io_pipe_info_ptr->READ_MUTEX, &mutex_attr); #if MQX_CHECK_ERRORS if (result != MQX_EOK) { _mem_free(io_pipe_info_ptr); return (result); } /* Endif */ #endif result = _mutex_init(&io_pipe_info_ptr->WRITE_MUTEX, &mutex_attr); #if MQX_CHECK_ERRORS if (result != MQX_EOK) { _mem_free(io_pipe_info_ptr); return (result); } /* Endif */ #endif result = _mutex_init(&io_pipe_info_ptr->ACCESS_MUTEX, &mutex_attr); #if MQX_CHECK_ERRORS if (result != MQX_EOK) { _mem_free(io_pipe_info_ptr); return (result); } /* Endif */ #endif /* Initialize semaphores */ result = _lwsem_create(&io_pipe_info_ptr->FULL_SEM, 0); #if MQX_CHECK_ERRORS if (result != MQX_OK) { _mem_free(io_pipe_info_ptr); return (result); } /* Endif */ #endif result = _lwsem_create(&io_pipe_info_ptr->EMPTY_SEM, 0); #if MQX_CHECK_ERRORS if (result != MQX_OK) { _mem_free(io_pipe_info_ptr); return (result); } /* Endif */ #endif /* Allocate queue structure for pipe char queue */ io_pipe_info_ptr->QUEUE = (void *)_mem_alloc_system( sizeof(CHARQ_STRUCT) - (4 * sizeof(char)) + io_pipe_info_ptr->QUEUE_SIZE); #if MQX_CHECK_MEMORY_ALLOCATION_ERRORS if (io_pipe_info_ptr->QUEUE == NULL){ _mem_free(io_pipe_info_ptr); return(MQX_OUT_OF_MEMORY); }/* Endif */ #endif /* Initialize Pipe queue */ _CHARQ_INIT(io_pipe_info_ptr->QUEUE, io_pipe_init_ptr->QUEUE_SIZE); return(result); } /* Endbody */
uint_32 _ki2c_polled_init ( /* [IN] Initialization information for the device being opened */ KI2C_INIT_STRUCT_PTR io_init_ptr, /* [OUT] Address to store device specific information */ pointer _PTR_ io_info_ptr_ptr, /* [IN] The rest of the name of the device opened */ char_ptr open_name_ptr ) { /* Body */ I2C_MemMapPtr i2c_ptr; VKI2C_INFO_STRUCT_PTR io_info_ptr; i2c_ptr = _bsp_get_i2c_base_address (io_init_ptr->CHANNEL); if (NULL == i2c_ptr) { return I2C_ERROR_CHANNEL_INVALID; } io_info_ptr = (VKI2C_INFO_STRUCT_PTR)_mem_alloc_system_zero ((uint_32)sizeof (KI2C_INFO_STRUCT)); if (NULL == io_info_ptr) { return MQX_OUT_OF_MEMORY; } _mem_set_type ((pointer)io_info_ptr, MEM_TYPE_IO_I2C_INFO_STRUCT); /* I2C board specific initialization */ _bsp_i2c_io_init (io_init_ptr->CHANNEL); *io_info_ptr_ptr = (pointer)io_info_ptr; io_info_ptr->INIT = *io_init_ptr; io_info_ptr->I2C_PTR = i2c_ptr; io_info_ptr->OLD_ISR = NULL; io_info_ptr->OLD_ISR_DATA = NULL; io_info_ptr->VECTOR = 0; io_info_ptr->MODE = io_init_ptr->MODE; io_info_ptr->STATE = I2C_STATE_READY; io_info_ptr->ADDRESSEE = 0; io_info_ptr->OPERATION = 0; io_info_ptr->RX_REQUEST = 0; io_info_ptr->RX_BUFFER = NULL; io_info_ptr->RX_IN = 0; io_info_ptr->RX_OUT = 0; io_info_ptr->TX_BUFFER = NULL; io_info_ptr->TX_IN = 0; io_info_ptr->TX_OUT = 0; io_info_ptr->STATISTICS.INTERRUPTS = 0; io_info_ptr->STATISTICS.RX_PACKETS = 0; io_info_ptr->STATISTICS.TX_PACKETS = 0; io_info_ptr->STATISTICS.TX_LOST_ARBITRATIONS = 0; io_info_ptr->STATISTICS.TX_ADDRESSED_AS_SLAVE = 0; io_info_ptr->STATISTICS.TX_NAKS = 0; /* Disable and clear I2C before initializing it */ i2c_ptr->C1 = 0x00; /* Clear out all I2C events */ i2c_ptr->S = 0x00; /* Set the station address for SLAVE receive operations */ i2c_ptr->A1 = io_init_ptr->STATION_ADDRESS << 1; /* Set the frequency divider for the nearest found baud rate */ i2c_ptr->F = _ki2c_set_baudrate( BSP_I2C_CLOCK, io_init_ptr->BAUD_RATE ); /* Enable I2C */ i2c_ptr->C1 |= I2C_C1_IICEN_MASK; return I2C_OK; } /* Endbody */
int_32 Shell_smtp (int_32 argc, char_ptr argv[]) { struct addrinfo hints; struct addrinfo *result, *rp; int_32 retval = 0; uint_32 sfd = 0; int_32 err_code = 0; boolean print_help; boolean shorthelp = FALSE; SMTP_PARAM_STRUCT params; char_ptr errstr = NULL; char_ptr server = NULL; char_ptr optstring = ":f:t:s:u:p:m:h"; int_32 next_option; char_ptr email_text = NULL; uint_32 email_size = 0; MQX_TICK_STRUCT ticks; MQX_XDATE_STRUCT xdate; char date_str[DATE_LENGTH]; params.login = NULL; params.pass = NULL; print_help = Shell_check_help_request(argc, argv, &shorthelp); if (print_help) { if (!shorthelp) { fprintf(stdout,"Usage:"); } fprintf(stdout, "%s", argv[0]); print_usage(stdout, shorthelp); err_code = SHELL_EXIT_SUCCESS; return(err_code); } /* Parse command line options */ do { next_option = Shell_getopt(argc, argv, optstring); switch (next_option) { case 'f': params.envelope.from = optarg; break; case 't': params.envelope.to = optarg; break; case 'm': params.text = optarg; break; case 's': server = optarg; break; case 'u': params.login = optarg; break; case 'p': params.pass = optarg; break; case 'h': print_usage (stdout, FALSE); return(SHELL_EXIT_SUCCESS); case '?': /* The user specified an invalid option. */ print_usage(stderr, TRUE); return(SHELL_EXIT_ERROR); case ':': /* Option has a missing parameter. */ printf("Option -%c requires a parameter.\n", next_option); return(SHELL_EXIT_ERROR); case -1: /* Done with options. */ break; default: break; } }while(next_option != -1); _time_get_ticks(&ticks); _time_ticks_to_xdate(&ticks,&xdate); snprintf(date_str, DATE_LENGTH, "%s, %d %s %d %02d:%02d:%02d -0000", wday[xdate.WDAY],xdate.MDAY, months[xdate.MONTH-1],xdate.YEAR, xdate.HOUR, xdate.MIN, xdate.SEC); /* Evaluate email size */ email_size = strlen(params.envelope.from) + strlen(params.envelope.to) + strlen(params.text) + strlen(date_str) + strlen("From: <>\r\n") + strlen("To: <>\r\n") + strlen("Subject: Freescale Tower Email\r\n") + strlen("Date: \r\n\r\n") + strlen("\r\n") + 1; /* Allocate space */ email_text = (char_ptr) _mem_alloc_zero(email_size); if (email_text == NULL) { fprintf(stderr, " Unable to allocate memory for email message.\n"); err_code = SHELL_EXIT_ERROR; return(err_code); } /* Prepare email message */ snprintf(email_text, email_size, "From: <%s>\r\n" "To: <%s>\r\n" "Subject: Freescale Tower Email\r\n" "Date: %s\r\n\r\n" "%s\r\n", params.envelope.from, params.envelope.to, date_str, params.text); params.text = email_text; _mem_zero(&hints, sizeof(hints)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; /* TCP socket */ hints.ai_flags = AI_PASSIVE; /* For wildcard IP address */ hints.ai_protocol = 0; /* Any protocol */ hints.ai_canonname = NULL; hints.ai_addr = NULL; hints.ai_next = NULL; retval = getaddrinfo(server, NULL, &hints, &result); if (retval != 0) { fprintf(stderr, " getaddrinfo failed. Error: 0x%X\n", retval); err_code = SHELL_EXIT_ERROR; return(err_code); } /* Allocate buffer for error message */ errstr = (char_ptr) _mem_alloc_system_zero(ERR_MSG_BUFF_SIZE); /* Try to send email using one of addresses. If it fails try another one. */ for (rp = result; rp != NULL; rp = rp->ai_next) { _mem_copy(rp->ai_addr, ¶ms.server, sizeof(params.server)); /* Try to send email */ retval = SMTP_send_email(¶ms, errstr, ERR_MSG_BUFF_SIZE); /* If connection failed try another address */ if (retval != SMTP_ERR_CONN_FAILED) { break; } } /* No address succeeded */ if (rp == NULL) { fprintf(stderr, " Unable to connect to %s.\n", server); err_code = SHELL_EXIT_ERROR; } if (retval != SMTP_OK) { printf(" Email sending failed%s %s\n", (strlen(errstr) > 0) ? ":":".", errstr); err_code = SHELL_EXIT_ERROR; } else { printf(" Email send. Server response: %s", errstr); } /* Cleanup */ freeaddrinfo(result); _mem_free(errstr); _mem_free(email_text); return(err_code); }
/* * Allocate server structure, init sockets, etc. */ FTPSRV_STRUCT* ftpsrv_create_server(FTPSRV_PARAM_STRUCT* params) { FTPSRV_STRUCT *server = NULL; uint32_t error; uint32_t error4 = FTPSRV_OK; uint32_t error6 = FTPSRV_OK; if ((server = _mem_alloc_system_zero(sizeof(FTPSRV_STRUCT))) == NULL) { return(NULL); } _mem_set_type(server, MEM_TYPE_FTPSRV_STRUCT); error = _lwsem_create(&server->tid_sem, 1); if (error != MQX_OK) { goto EXIT; } error = ftpsrv_set_params(server, params); if (error != FTPSRV_OK) { goto EXIT; } /* Allocate space for session pointers */ server->session = RTCS_mem_alloc_zero(sizeof(FTPSRV_SESSION_STRUCT*) * server->params.max_ses); if (server->session == NULL) { goto EXIT; } /* Allocate space for session task IDs */ server->ses_tid = RTCS_mem_alloc_zero(sizeof(_rtcs_taskid) * server->params.max_ses); if (server->ses_tid == NULL) { goto EXIT; } /* Init sockets. */ if (params->af & AF_INET) { /* Setup IPv4 server socket */ error4 = ftpsrv_init_socket(server, AF_INET); } if (params->af & AF_INET6) { /* Setup IPv6 server socket */ error6 = ftpsrv_init_socket(server, AF_INET6); } if ((error4 != FTPSRV_OK) || (error6 != FTPSRV_OK)) { ftpsrv_destroy_server(server); return(NULL); } server->run = 1; return(server); EXIT: ftpsrv_destroy_server(server); return(NULL); }
_mqx_uint _event_create_internal ( /* [IN] the string name for the event */ char _PTR_ name_ptr, /* [OUT] where the event pointer is */ EVENT_STRUCT_PTR _PTR_ event_ptr_ptr ) { /* Body */ KERNEL_DATA_STRUCT_PTR kernel_data; register EVENT_COMPONENT_STRUCT_PTR event_component_ptr; register EVENT_STRUCT_PTR event_ptr; _mqx_uint result; _GET_KERNEL_DATA(kernel_data); _KLOGE2(KLOG_event_create, name_ptr); #if MQX_CHECK_ERRORS if (kernel_data->IN_ISR) { _KLOGX2(KLOG_event_create, MQX_CANNOT_CALL_FUNCTION_FROM_ISR); return(MQX_CANNOT_CALL_FUNCTION_FROM_ISR); } /* Endif */ #endif event_component_ptr = (EVENT_COMPONENT_STRUCT_PTR) kernel_data->KERNEL_COMPONENTS[KERNEL_EVENTS]; if (event_component_ptr == NULL) { result = _event_create_component(EVENT_DEFAULT_INITIAL_NUMBER, EVENT_DEFAULT_GROW_NUMBER, EVENT_DEFAULT_MAXIMUM_NUMBER); event_component_ptr = (EVENT_COMPONENT_STRUCT_PTR) kernel_data->KERNEL_COMPONENTS[KERNEL_EVENTS]; #if MQX_CHECK_MEMORY_ALLOCATION_ERRORS if (event_component_ptr == NULL){ _KLOGX2(KLOG_event_create, result); return(result); } /* Endif */ #endif } /* Endif */ #if MQX_CHECK_VALIDITY if (event_component_ptr->VALID != EVENT_VALID){ _KLOGX2(KLOG_event_create, MQX_INVALID_COMPONENT_BASE); return(MQX_INVALID_COMPONENT_BASE); } /* Endif */ #endif event_ptr = (EVENT_STRUCT_PTR)_mem_alloc_system_zero( (_mem_size)sizeof(EVENT_STRUCT)); #if MQX_CHECK_MEMORY_ALLOCATION_ERRORS if (event_ptr == NULL) { _KLOGX2(KLOG_event_create, MQX_OUT_OF_MEMORY); return(MQX_OUT_OF_MEMORY); } /* Endif */ #endif _mem_set_type(event_ptr, MEM_TYPE_EVENT); _QUEUE_INIT(&event_ptr->WAITING_TASKS, EVENT_MAX_WAITING_TASKS); strncpy(event_ptr->NAME, name_ptr, (_mqx_uint)NAME_MAX_NAME_SIZE-1); event_ptr->NAME[NAME_MAX_NAME_SIZE-1] = '\0'; result = _name_add_internal(event_component_ptr->NAME_TABLE_HANDLE, event_ptr->NAME, (_mqx_uint)event_ptr); #if MQX_CHECK_ERRORS if (result != MQX_OK) { _mem_free(event_ptr); if (result == NAME_EXISTS) { _KLOGX2(KLOG_event_create, EVENT_EXISTS); return(EVENT_EXISTS); } else if (result == NAME_TABLE_FULL) { _KLOGX2(KLOG_event_create, EVENT_TABLE_FULL); return(EVENT_TABLE_FULL); } /* Endif */ _KLOGX2(KLOG_event_create, result); return(result); } /* Endif */ #endif event_ptr->VALID = EVENT_VALID; *event_ptr_ptr = event_ptr; _KLOGX2(KLOG_event_create, result); return(result); } /* Endbody */
_mqx_uint _io_asrc_install ( /* [IN] A string that identifies the device for fopen */ char * identifier, /* [IN] The I/O init function */ _mqx_uint (_CODE_PTR_ init)(void *, void * *), /* The I/O open function */ _mqx_uint (_CODE_PTR_ open)(void *, void *, char *), /* The I/O open function */ _mqx_uint (_CODE_PTR_ close)(void *, void *), /* [IN] The I/O de-init function */ _mqx_uint (_CODE_PTR_ deinit)(void *), /* [IN] The I/O ioctl function */ _mqx_int (_CODE_PTR_ ioctl)(void *, void *, _mqx_uint, _mqx_uint_ptr), /* [IN] The I/O init data pointer */ void * init_data_ptr, /* [IN] functions for pcm manager*/ ASRC_PCMM_FUNCS_STRUCT_PTR pcmm_funcs_ptr ) { /* Body */ IO_ASRC_DEVICE_STRUCT_PTR asrc_io_dev_ptr; MUTEX_ATTR_STRUCT mutex_attr; asrc_io_dev_ptr = (IO_ASRC_DEVICE_STRUCT_PTR)_mem_alloc_system_zero( (_mem_size)sizeof (IO_ASRC_DEVICE_STRUCT)); if (asrc_io_dev_ptr == NULL) { return MQX_OUT_OF_MEMORY; } _mem_set_type (asrc_io_dev_ptr, MEM_TYPE_IO_ASRC_DEVICE_STRUCT); asrc_io_dev_ptr->DEV_INIT = init; asrc_io_dev_ptr->DEV_OPEN = open; asrc_io_dev_ptr->DEV_CLOSE = close; asrc_io_dev_ptr->DEV_DEINIT = deinit; asrc_io_dev_ptr->DEV_IOCTL = ioctl; asrc_io_dev_ptr->DEV_INIT_DATA_PTR = init_data_ptr; asrc_io_dev_ptr->DEV_INFO_PTR = NULL; asrc_io_dev_ptr->COUNT = 0; asrc_io_dev_ptr->PCMM_DRV_FUNCS_PTR = pcmm_funcs_ptr; _mutatr_init(&mutex_attr); _mutatr_set_sched_protocol(&mutex_attr, MUTEX_PRIO_INHERIT); _mutex_init(&asrc_io_dev_ptr->DEV_MUTEX, &mutex_attr); if (NULL != pcmm_funcs_ptr) { /*register to pcm manager*/ /*set pcm handle to a valid value*/ asrc_io_dev_ptr->PCMM_DRV_HANDLE = PCMM_HANDLE_ASRC_VALID; } return (_io_dev_install_ext (identifier, _io_asrc_open, _io_asrc_close, NULL, NULL, _io_asrc_ioctl, _io_asrc_uninstall, (void *)asrc_io_dev_ptr)); } /* Endbody */
/*FUNCTION**************************************************************** * * Function Name : _dspi_dma_init * Returned Value : MQX error code * Comments : * This function initializes the SPI driver * *END*********************************************************************/ static _mqx_int _dspi_dma_init ( /* [IN] The initialization information for the device being opened */ const void *init_data_ptr, /* [OUT] The address to store device specific information */ void **io_info_ptr_ptr ) { DSPI_DMA_INIT_STRUCT_PTR dspi_init_ptr = (DSPI_DMA_INIT_STRUCT_PTR)init_data_ptr; DSPI_DMA_INFO_STRUCT_PTR dspi_info_ptr; VDSPI_REG_STRUCT_PTR dspi_ptr; int result; #if PSP_HAS_DEVICE_PROTECTION if (!_bsp_dspi_enable_access(dspi_init_ptr->CHANNEL)) { return SPI_ERROR_CHANNEL_INVALID; } #endif /* Check channel */ dspi_ptr = _bsp_get_dspi_base_address (dspi_init_ptr->CHANNEL); if (NULL == dspi_ptr) { return SPI_ERROR_CHANNEL_INVALID; } if (_bsp_dspi_io_init (dspi_init_ptr->CHANNEL) == -1) { return SPI_ERROR_CHANNEL_INVALID; } /* Initialize internal data */ dspi_info_ptr = (DSPI_DMA_INFO_STRUCT_PTR)_mem_alloc_system_zero((uint32_t)sizeof(DSPI_DMA_INFO_STRUCT)); if (dspi_info_ptr == NULL) { return MQX_OUT_OF_MEMORY; } _mem_set_type(dspi_info_ptr, MEM_TYPE_IO_SPI_INFO_STRUCT); *io_info_ptr_ptr = (void *)dspi_info_ptr; dspi_info_ptr->DSPI_PTR = dspi_ptr; dspi_info_ptr->CHANNEL = dspi_init_ptr->CHANNEL; dspi_info_ptr->CLOCK_SOURCE = dspi_init_ptr->CLOCK_SOURCE; _dspi_init_low(dspi_info_ptr->DSPI_PTR); /* Claim DMA channels and perform setup */ if ((result = dma_channel_claim(&dspi_info_ptr->DMA_RX_CHANNEL, dspi_init_ptr->DMA_RX_CHANNEL)) != MQX_OK || (result = dma_channel_claim(&dspi_info_ptr->DMA_TX_CHANNEL, dspi_init_ptr->DMA_TX_CHANNEL)) != MQX_OK || (result = dma_channel_setup(dspi_info_ptr->DMA_RX_CHANNEL, 1, 0)) != MQX_OK || (result = dma_channel_setup(dspi_info_ptr->DMA_TX_CHANNEL, 1, 0)) != MQX_OK || (result = dma_request_source(dspi_info_ptr->DMA_RX_CHANNEL, dspi_init_ptr->DMA_RX_SOURCE)) != MQX_OK || (result = dma_request_source(dspi_info_ptr->DMA_TX_CHANNEL, dspi_init_ptr->DMA_TX_SOURCE)) != MQX_OK ) { dma_channel_release(dspi_info_ptr->DMA_RX_CHANNEL); dma_channel_release(dspi_info_ptr->DMA_TX_CHANNEL); _mem_free(dspi_info_ptr); return result; } /* Allocate cache line aligned block of memory and split it in half to form RX and TX buffer */ dspi_info_ptr->RX_BUF = _mem_alloc_system(4*PSP_CACHE_LINE_SIZE); if (dspi_info_ptr->RX_BUF == NULL) { dma_channel_release(dspi_info_ptr->DMA_RX_CHANNEL); dma_channel_release(dspi_info_ptr->DMA_TX_CHANNEL); _mem_free(dspi_info_ptr); return MQX_OUT_OF_MEMORY; } dspi_info_ptr->TX_BUF = dspi_info_ptr->RX_BUF + 2*PSP_CACHE_LINE_SIZE; _lwsem_create(&dspi_info_ptr->EVENT_IO_FINISHED, 0); dma_callback_reg(dspi_info_ptr->DMA_RX_CHANNEL, _dspi_dma_callback, dspi_info_ptr); /* Route data s to DMA */ dspi_ptr->RSER = DSPI_RSER_RFDF_DIRS_MASK | DSPI_RSER_RFDF_RE_MASK | DSPI_RSER_TFFF_DIRS_MASK | DSPI_RSER_TFFF_RE_MASK; dma_request_enable(dspi_info_ptr->DMA_RX_CHANNEL); dma_request_enable(dspi_info_ptr->DMA_TX_CHANNEL); return SPI_OK; }
_mqx_uint _io_pcb_shm_install ( /* [IN] the name of this device */ char *device_name_ptr, /* [IN] the initialization record for this device */ void *init_ptr ) { IO_PCB_SHM_INFO_STRUCT_PTR info_ptr; uint32_t tmp; info_ptr = _mem_alloc_system_zero(sizeof(IO_PCB_SHM_INFO_STRUCT)); if (info_ptr == NULL) { return(MQX_OUT_OF_MEMORY); } info_ptr->INIT = *((IO_PCB_SHM_INIT_STRUCT_PTR)init_ptr); /* Initialize the info structure */ /* ** Set the Tx and Rx RINGPTR address base ** */ info_ptr->TX_RING_PTR = (IO_PCB_SHM_BUFFER_STRUCT_PTR)( ((IO_PCB_SHM_INIT_STRUCT_PTR)init_ptr)->TX_BD_ADDR); info_ptr->TX_RING_PTR = (IO_PCB_SHM_BUFFER_STRUCT_PTR) SHM_DESCR_ALIGN((uint32_t)info_ptr->TX_RING_PTR); tmp = (uint32_t)(IO_PCB_SHM_BUFFER_STRUCT_PTR)(((IO_PCB_SHM_INIT_STRUCT_PTR) init_ptr)->TX_LIMIT_ADDR); tmp -= (uint32_t)(info_ptr->TX_RING_PTR); tmp /= sizeof(IO_PCB_SHM_BUFFER_STRUCT); info_ptr->TXENTRIES = tmp; info_ptr->TX_LENGTH = tmp; info_ptr->TXNEXT = 0; info_ptr->TXLAST = 0; info_ptr->RX_RING_PTR = (IO_PCB_SHM_BUFFER_STRUCT_PTR)( ((IO_PCB_SHM_INIT_STRUCT_PTR)init_ptr)->RX_BD_ADDR); info_ptr->RX_RING_PTR = (IO_PCB_SHM_BUFFER_STRUCT_PTR) SHM_DESCR_ALIGN((uint32_t)info_ptr->RX_RING_PTR); tmp = (uint32_t)(IO_PCB_SHM_BUFFER_STRUCT_PTR)(((IO_PCB_SHM_INIT_STRUCT_PTR) init_ptr)->RX_LIMIT_ADDR); tmp -= (uint32_t)(info_ptr->RX_RING_PTR); tmp /= sizeof(IO_PCB_SHM_BUFFER_STRUCT); info_ptr->RXENTRIES = tmp; info_ptr->RX_LENGTH = tmp; info_ptr->RXNEXT = 0; info_ptr->RXLAST = 0; return (_io_dev_install_ext(device_name_ptr, _io_pcb_shm_open, _io_pcb_shm_close, _io_pcb_shm_read, _io_pcb_shm_write, _io_pcb_shm_ioctl, _io_pcb_shm_uninstall, (void *)info_ptr)); }
pointer usb_filesystem_install( pointer usb_handle, char_ptr block_device_name, char_ptr partition_manager_name, char_ptr file_system_name ) { uint_32 partition_number; uchar_ptr dev_info; int_32 error_code; USB_FILESYSTEM_STRUCT_PTR usb_fs_ptr; usb_fs_ptr = _mem_alloc_system_zero(sizeof(USB_FILESYSTEM_STRUCT)); if (usb_fs_ptr==NULL) { return NULL; } /* Install USB device */ error_code = _io_usb_mfs_install(block_device_name, 0, (pointer)usb_handle); if (error_code != MQX_OK) { printf("Error while installing USB device (0x%X)\n", error_code); return NULL; } usb_fs_ptr->DEV_NAME = block_device_name; /* Open the USB mass storage device */ _time_delay(500); // printf("open msd dev\n"); usb_fs_ptr->DEV_FD_PTR = fopen(block_device_name, 0); if (usb_fs_ptr->DEV_FD_PTR == NULL) { printf("Unable to open USB device\n"); /*usb_filesystem_uninstall*/usb_filesystem_cancel_install(usb_fs_ptr,USB_DEV_OPEN_FAIL); return NULL; } _io_ioctl(usb_fs_ptr->DEV_FD_PTR, IO_IOCTL_SET_BLOCK_MODE, NULL); /* Get the vendor information and display it */ printf("\n************************************************************************\n"); _io_ioctl(usb_fs_ptr->DEV_FD_PTR, USB_MFS_IOCTL_GET_VENDOR_INFO, &dev_info); printf("Vendor Information: %-1.8s Mass Storage Device\n",dev_info); _io_ioctl(usb_fs_ptr->DEV_FD_PTR, USB_MFS_IOCTL_GET_PRODUCT_ID, &dev_info); printf("Product Identification: %-1.16s\n",dev_info); _io_ioctl(usb_fs_ptr->DEV_FD_PTR, USB_MFS_IOCTL_GET_PRODUCT_REV, &dev_info); printf("Product Revision Level: %-1.4s\n",dev_info); printf("************************************************************************\n"); /* Try to install the partition manager */ // printf("_io_part_mgr_install\n"); error_code = _io_part_mgr_install(usb_fs_ptr->DEV_FD_PTR, partition_manager_name, 0); if (error_code != MFS_NO_ERROR) { printf("Error while initializing partition manager: %s\n", MFS_Error_text((uint_32)error_code)); /* usb_filesystem_uninstall */usb_filesystem_cancel_install(usb_fs_ptr,PARTITION_INIT_FAIL); return NULL; } usb_fs_ptr->PM_NAME = partition_manager_name; /* Open partition manager */ // printf("fopen partition\n"); usb_fs_ptr->PM_FD_PTR = fopen(partition_manager_name, NULL); if (usb_fs_ptr->PM_FD_PTR == NULL) { error_code = ferror(usb_fs_ptr->PM_FD_PTR); printf("Error while opening partition manager: %s\n", MFS_Error_text((uint_32)error_code)); /*usb_filesystem_uninstall*/usb_filesystem_cancel_install(usb_fs_ptr,PARTITION_OPEN_FAIL); return NULL; } /* Select partition */ partition_number = 1; // printf("select partition\n"); error_code = _io_ioctl(usb_fs_ptr->PM_FD_PTR, IO_IOCTL_SEL_PART, &partition_number); if (error_code == MFS_NO_ERROR) { printf("Installing MFS over partition...\n"); /* Validate partition */ // printf("Validate partition\n"); error_code = _io_ioctl(usb_fs_ptr->PM_FD_PTR, IO_IOCTL_VAL_PART, NULL); if (error_code != MFS_NO_ERROR) { printf("Error while validating partition: %s\n", MFS_Error_text((uint32_t)error_code)); printf("Not installing MFS.\n"); /*usb_filesystem_uninstall*/usb_filesystem_cancel_install(usb_fs_ptr,PARTITION_VALIDATE_FAIL); return NULL; } /* Install MFS over partition */ //printf("Install MFS over partition\n"); error_code = _io_mfs_install(usb_fs_ptr->PM_FD_PTR, file_system_name, 0); if (error_code != MFS_NO_ERROR) { printf("Error initializing MFS over partition: %s\n", MFS_Error_text((uint_32)error_code)); } } else { printf("Installing MFS over USB device...\n"); /* Install MFS over USB device driver */ //printf("Install MFS over USB device driver\n"); error_code = _io_mfs_install(usb_fs_ptr->DEV_FD_PTR, file_system_name, 0); if (error_code != MFS_NO_ERROR) { printf("Error initializing MFS: %s\n", MFS_Error_text((uint_32)error_code)); } } /* Open file system */ if (error_code == MFS_NO_ERROR) { usb_fs_ptr->FS_NAME = file_system_name; //printf("Open file system\n"); usb_fs_ptr->FS_FD_PTR = fopen(file_system_name, NULL); error_code = ferror(usb_fs_ptr->FS_FD_PTR); if (error_code == MFS_NOT_A_DOS_DISK) { printf("NOT A DOS DISK! You must format to continue.\n"); } else if (error_code != MFS_NO_ERROR) { printf("Error opening filesystem: %s\n", MFS_Error_text((uint_32)error_code)); /* usb_filesystem_uninstall*/usb_filesystem_cancel_install(usb_fs_ptr,MFS_OPEN_FAIL); return NULL; } printf("USB device installed to %s\n", file_system_name); } else { /*usb_filesystem_uninstall*/usb_filesystem_cancel_install(usb_fs_ptr,MFS_INIT_FAIL); return NULL; } return (pointer)usb_fs_ptr; }
uint_32 _mcf53xx_uart_serial_polled_init ( /* [IN] the initialization information for the device being opened */ MCF53XX_UART_SERIAL_INIT_STRUCT_PTR io_init_ptr, /* [OUT] the address to store device specific information */ pointer _PTR_ io_info_ptr_ptr, /* [IN] the rest of the name of the device opened */ char _PTR_ open_name_ptr ) { /* Body */ volatile MCF53XX_UART_STRUCT _PTR_ uart_ptr; MCF53XX_UART_SERIAL_INFO_STRUCT _PTR_ uart_info_ptr; uint_32 channel; uint_32 baud; uart_info_ptr = _mem_alloc_system_zero((uint_32) sizeof(MCF53XX_UART_SERIAL_INFO_STRUCT)); #if MQX_CHECK_MEMORY_ALLOCATION_ERRORS if ( uart_info_ptr == NULL ) { return(MQX_OUT_OF_MEMORY); }/* Endif */ #endif _mem_set_type(uart_info_ptr,MEM_TYPE_IO_SERIAL_INFO_STRUCT); *io_info_ptr_ptr = uart_info_ptr; /* Save initialization values */ uart_info_ptr->INIT = *io_init_ptr; channel = uart_info_ptr->INIT.DEVICE; _bsp_serial_io_init (channel); uart_ptr = _bsp_get_serial_base_address (channel); uart_info_ptr->UART_PTR = (pointer)uart_ptr; uart_ptr->WRITE.UCR = MCF53XX_UART_UCR_RESET_RX; uart_ptr->WRITE.UCR = MCF53XX_UART_UCR_RESET_TX; uart_ptr->WRITE.UCR = MCF53XX_UART_UCR_RESET_ERROR; uart_ptr->WRITE.UCR = MCF53XX_UART_UCR_RESET_BREAK; uart_ptr->WRITE.UCR = MCF53XX_UART_UCR_RESET_POINTER; uart_ptr->WRITE.UMR = uart_info_ptr->INIT.UMR1_VALUE; uart_ptr->WRITE.UMR = uart_info_ptr->INIT.UMR2_VALUE; uart_ptr->WRITE.UCSR = MCF53XX_UART_UCSR_RX_TIMER | MCF53XX_UART_UCSR_TX_TIMER; uart_ptr->WRITE.UIMR = 0; /* Disable all interrupts */ /* Set up the baud rate */ /* baud = fsck / (32 * baudrate) + 0.5 */ baud = (uart_info_ptr->INIT.CLOCK_SPEED + (16 * uart_info_ptr->INIT.BAUD_RATE) ) / (32 * uart_info_ptr->INIT.BAUD_RATE); uart_ptr->WRITE.UBG1 = (uchar)((baud >> 8) & 0xFF); uart_ptr->WRITE.UBG2 = (uchar)(baud & 0xFF); uart_ptr->WRITE.UCR = MCF53XX_UART_UCR_TX_ENABLE | MCF53XX_UART_UCR_RX_ENABLE; return( MQX_OK ); } /* Endbody */
pointer calloc(unsigned int n, unsigned int z) { return _mem_alloc_system_zero(n*z); }
/*! * \brief Override C/C++ runtime heap allocation function in IAR's DLIB * * \param n * \param z * * \return pointer */ void *calloc(_mem_size n, _mem_size z) { return _mem_alloc_system_zero(n*z); }
_mqx_uint _io_serial_int_install ( /* [IN] A string that identifies the device for fopen */ char *identifier, /* [IN] The I/O init function */ _mqx_uint (_CODE_PTR_ init)(void *, char *), /* [IN] The enable interrupts function */ _mqx_uint (_CODE_PTR_ enable_ints)(void *), /* [IN] The I/O de-init function */ _mqx_uint (_CODE_PTR_ deinit)(void *, void *), /* [IN] The output function */ void (_CODE_PTR_ putc)(void *, char), /* [IN] The I/O ioctl function */ _mqx_uint (_CODE_PTR_ ioctl)(void *, _mqx_uint, void *), /* [IN] The I/O init data pointer */ void *init_data_ptr, /* [IN] The I/O queue size to use */ _mqx_uint queue_size ) { /* Body */ IO_SERIAL_INT_DEVICE_STRUCT_PTR int_io_dev_ptr; uint32_t result; int_io_dev_ptr = _mem_alloc_system_zero( (_mem_size)sizeof(IO_SERIAL_INT_DEVICE_STRUCT)); #if MQX_CHECK_MEMORY_ALLOCATION_ERRORS if (int_io_dev_ptr == NULL) { return(MQX_OUT_OF_MEMORY); } /* Endif */ #endif _mem_set_type(int_io_dev_ptr,MEM_TYPE_IO_SERIAL_INT_DEVICE_STRUCT); int_io_dev_ptr->DEV_INIT = init; int_io_dev_ptr->DEV_ENABLE_INTS = enable_ints; int_io_dev_ptr->DEV_DEINIT = deinit; int_io_dev_ptr->DEV_PUTC = putc; int_io_dev_ptr->DEV_IOCTL = ioctl; int_io_dev_ptr->DEV_INIT_DATA_PTR = init_data_ptr; int_io_dev_ptr->QUEUE_SIZE = queue_size; result = _io_dev_install(identifier, _io_serial_int_open, _io_serial_int_close, _io_serial_int_read, _io_serial_int_write, _io_serial_int_ioctl, (void *)int_io_dev_ptr); #if MQX_ENABLE_LOW_POWER if (MQX_OK == result) { LPM_REGISTRATION_STRUCT registration; registration.CLOCK_CONFIGURATION_CALLBACK = _io_serial_int_clock_configuration_callback; registration.OPERATION_MODE_CALLBACK = _io_serial_int_operation_mode_callback; registration.DEPENDENCY_LEVEL = BSP_LPM_DEPENDENCY_LEVEL_SERIAL_INT; result = _lpm_register_driver (®istration, int_io_dev_ptr, &(int_io_dev_ptr->LPM_INFO.REGISTRATION_HANDLE)); if (MQX_OK == result) { _lwsem_create (&(int_io_dev_ptr->LPM_INFO.LOCK), 1); int_io_dev_ptr->LPM_INFO.FLAGS = 0; } } #endif return result; } /* Endbody */
_mqx_uint _event_create_component ( /* [IN] the initial number of event */ _mqx_uint initial_number, /* ** [IN] the number of events to add when ** space is no longer available */ _mqx_uint grow_number, /* [IN] the maximum number of events allowed */ _mqx_uint maximum_number ) { /* Body */ KERNEL_DATA_STRUCT_PTR kernel_data; register EVENT_COMPONENT_STRUCT_PTR event_component_ptr; _mqx_uint result; _GET_KERNEL_DATA(kernel_data); _KLOGE4(KLOG_event_create_component, initial_number, grow_number, maximum_number); #if MQX_CHECK_ERRORS if (kernel_data->IN_ISR) { _KLOGX2(KLOG_event_create_component, MQX_CANNOT_CALL_FUNCTION_FROM_ISR); return(MQX_CANNOT_CALL_FUNCTION_FROM_ISR); } /* Endif */ #endif _lwsem_wait((LWSEM_STRUCT_PTR)(&kernel_data->COMPONENT_CREATE_LWSEM)); event_component_ptr = (EVENT_COMPONENT_STRUCT_PTR) kernel_data->KERNEL_COMPONENTS[KERNEL_EVENTS]; if (event_component_ptr != NULL) { _lwsem_post((LWSEM_STRUCT_PTR)(&kernel_data->COMPONENT_CREATE_LWSEM)); _KLOGX2(KLOG_event_create_component, MQX_OK); return(MQX_OK); } /* Endif */ event_component_ptr = (EVENT_COMPONENT_STRUCT_PTR) _mem_alloc_system_zero((_mem_size)sizeof(EVENT_COMPONENT_STRUCT)); #if MQX_CHECK_MEMORY_ALLOCATION_ERRORS if (event_component_ptr == NULL) { _lwsem_post((LWSEM_STRUCT_PTR)(&kernel_data->COMPONENT_CREATE_LWSEM)); _KLOGX2(KLOG_event_create_component, MQX_OUT_OF_MEMORY); return(MQX_OUT_OF_MEMORY); } /* Endif */ #endif _mem_set_type(event_component_ptr, MEM_TYPE_EVENT_COMPONENT); result = _name_create_handle_internal(&event_component_ptr->NAME_TABLE_HANDLE, initial_number, grow_number, maximum_number, initial_number); #if MQX_CHECK_ERRORS if (result != MQX_OK) { _lwsem_post((LWSEM_STRUCT_PTR)(&kernel_data->COMPONENT_CREATE_LWSEM)); _mem_free(event_component_ptr); _KLOGX2(KLOG_event_create_component, result); return(result); } /* Endif */ #endif event_component_ptr->VALID = EVENT_VALID; event_component_ptr->GROW_NUMBER = grow_number; if (maximum_number == 0) { event_component_ptr->MAXIMUM_NUMBER = MAX_MQX_UINT; } else if (maximum_number < initial_number) { event_component_ptr->MAXIMUM_NUMBER = initial_number; } else { event_component_ptr->MAXIMUM_NUMBER = maximum_number; } /* Endif */ kernel_data->KERNEL_COMPONENTS[KERNEL_EVENTS] = event_component_ptr; #if MQX_TASK_DESTRUCTION kernel_data->COMPONENT_CLEANUP[KERNEL_EVENTS] = _event_cleanup; #endif _lwsem_post((LWSEM_STRUCT_PTR)(&kernel_data->COMPONENT_CREATE_LWSEM)); _KLOGX2(KLOG_event_create_component, MQX_OK); return(MQX_OK); } /* Endbody */
_mqx_int gpio_cpu_open ( /* [IN] the file handle for the device */ MQX_FILE_PTR fd_ptr, /* [IN] the file name */ char_ptr file_name, /* [IN] pointer to parameters */ char_ptr param_ptr ) { /* Body */ _mqx_int i; GPIO_DEV_DATA_PTR dev_data_ptr = (GPIO_DEV_DATA_PTR) fd_ptr->DEV_DATA_PTR; /* if file_name is used, then the user wants to open peripheral */ if ((file_name != NULL) && (*file_name != 0)) { if (!strncmp(file_name, "gpio:write", 11)) /* user wants write access to GPIO */ dev_data_ptr->type = DEV_OUTPUT; else if (!strncmp(file_name, "gpio:output", 12)) /* user wants write access to GPIO */ dev_data_ptr->type = DEV_OUTPUT; else if (!strncmp(file_name, "gpio:read", 10)) /* user wants read access to GPIO */ dev_data_ptr->type = DEV_INPUT; else if (!strncmp(file_name, "gpio:input", 11)) /* user wants read access to GPIO */ dev_data_ptr->type = DEV_INPUT; else /* peripherals not used yet */ return IO_ERROR; } else return IO_ERROR; if ((param_ptr != NULL) && (dev_data_ptr->type == DEV_OUTPUT)) { /* set pins status before selecting GPIO function */ /* note that this is similar to GPIO_IOCTL_WRITE function, but no checking is performed (was done in io_gpio_open function) */ uint_32 _PTR_ pin_table; uint_32 addr; uint_8 pin; GPIO_PIN_MAP_PTR temp_pin0_map_ptr; GPIO_PIN_MAP_PTR temp_pin1_map_ptr; if (NULL == (temp_pin0_map_ptr = (GPIO_PIN_MAP_PTR) _mem_alloc_system_zero(sizeof(GPIO_PIN_MAP)))) return IO_ERROR; if (NULL == (temp_pin1_map_ptr = (GPIO_PIN_MAP_PTR) _mem_alloc_system_zero(sizeof(GPIO_PIN_MAP)))) { _mem_free(temp_pin0_map_ptr); return IO_ERROR; } /* prepare pin map */ for (pin_table = (uint_32 _PTR_) param_ptr; *pin_table != GPIO_LIST_END; pin_table++) { addr = (*pin_table & GPIO_PIN_ADDR) >> 3; /* prepare address of port */ pin = 1 << (*pin_table & 0x07); /* prepare bit mask */ if (*pin_table & GPIO_PIN_STATUS) temp_pin1_map_ptr->memory8[addr] |= pin; else temp_pin0_map_ptr->memory8[addr] |= pin; } /* first, configure pin as output */ gpio_cpu_configure(dev_data_ptr); /* ok, now we can apply new map */ /* note: applying the map after collecting pins is due to have pins applied in one instruction */ for (i = GPIO_PORT_A; i < GPIO_PORT_MAX; i++) mcf521cn_gpioX_ptr->PORT[i].PTxD = (mcf521cn_gpioX_ptr->PORT[i].PTxD | temp_pin1_map_ptr->reg.portt[i]) & ~temp_pin0_map_ptr->reg.portt[i]; _mem_free(temp_pin1_map_ptr); _mem_free(temp_pin0_map_ptr); }
/*FUNCTION**************************************************************** * * Function Name : _io_spi_install * Returned Value : MQX error code * Comments : * Installs SPI device. * *END**********************************************************************/ _mqx_int _io_spi_install ( /* [IN] A string that identifies the device for fopen */ char *identifier, /* [IN] Pointer to driver initialization data */ SPI_INIT_STRUCT_CPTR init_data_ptr ) { SPI_DRIVER_DATA_STRUCT_PTR driver_data; _mqx_int error_code = MQX_OK; if ((init_data_ptr->DEVIF->SETPARAM == NULL) || (init_data_ptr->DEVIF->TX_RX == NULL)) { /* Missing mandatory low level driver function */ return IO_ERROR_DEVICE_INVALID; } driver_data = (SPI_DRIVER_DATA_STRUCT_PTR)_mem_alloc_system_zero((_mem_size)sizeof(SPI_DRIVER_DATA_STRUCT)); if (driver_data == NULL) { return MQX_OUT_OF_MEMORY; } _mem_set_type(driver_data, MEM_TYPE_IO_SPI_POLLED_DEVICE_STRUCT); driver_data->CS_CALLBACK = init_data_ptr->CS_CALLBACK; driver_data->CS_USERDATA= init_data_ptr->CS_USERDATA; driver_data->PARAMS = init_data_ptr->PARAMS; driver_data->DEVIF = init_data_ptr->DEVIF; /* initialize low level driver */ if (driver_data->DEVIF->INIT) error_code = driver_data->DEVIF->INIT(init_data_ptr->DEVIF_INIT, &(driver_data->DEVIF_DATA)); if (error_code != MQX_OK) { _mem_free(driver_data); return error_code; } _lwsem_create(&driver_data->BUS_LOCK, 1); error_code = _io_dev_install_ext(identifier, _io_spi_open, _io_spi_close, _io_spi_read, _io_spi_write, _io_spi_ioctl, _io_spi_uninstall, (void *)driver_data); if (error_code) { /* deinitialize low level driver */ if (driver_data->DEVIF->DEINIT) driver_data->DEVIF->DEINIT(driver_data->DEVIF_DATA); _lwsem_destroy(&driver_data->BUS_LOCK); _mem_free(driver_data); return error_code; } return MQX_OK; }