/* west bridge device driver main init */ static int cyasdevice_initialize(void) { cyasdevice *cy_as_dev = 0; int ret = 0; int retval = 0; cy_as_device_config config; cy_as_hal_sleep_channel channel; cy_as_get_firmware_version_data ver_data = {0}; const char *str = ""; int spin_lim; const struct firmware *fw_entry; cy_as_device_init_done = 0; cy_as_misc_set_log_level(8); cy_as_hal_print_message("<1>_cy_as_device initialize called\n"); if (cy_as_device_controller != 0) { cy_as_hal_print_message("<1>_cy_as_device: the device " "has already been initilaized. ignoring\n"); return -EBUSY; } /* cy_as_dev = CyAsHalAlloc (sizeof(cyasdevice), SLAB_KERNEL); */ cy_as_dev = cy_as_hal_alloc(sizeof(cyasdevice)); if (cy_as_dev == NULL) { cy_as_hal_print_message("<1>_cy_as_device: " "memory allocation failed\n"); return -ENOMEM; } memset(cy_as_dev, 0, sizeof(cyasdevice)); /* Init the HAL & CyAsDeviceHandle */ #ifdef CONFIG_MACH_OMAP3_WESTBRIDGE_AST_PNAND_HAL /* start OMAP HAL init instsnce */ if (!start_o_m_a_p_kernel(dev_handle_name, &(cy_as_dev->hal_tag), cy_false)) { cy_as_hal_print_message( "<1>_cy_as_device: start OMAP34xx HAL failed\n"); goto done; } #endif /* Now create the device */ if (cy_as_misc_create_device(&(cy_as_dev->dev_handle), cy_as_dev->hal_tag) != CY_AS_ERROR_SUCCESS) { cy_as_hal_print_message( "<1>_cy_as_device: create device failed\n"); goto done; } memset(&config, 0, sizeof(config)); config.dmaintr = cy_true; ret = cy_as_misc_configure_device(cy_as_dev->dev_handle, &config); if (ret != CY_AS_ERROR_SUCCESS) { cy_as_hal_print_message( "<1>_cy_as_device: configure device " "failed. reason code: %d\n", ret); goto done; } ret = cy_as_misc_register_callback(cy_as_dev->dev_handle, cy_misc_callback); if (ret != CY_AS_ERROR_SUCCESS) { cy_as_hal_print_message("<1>_cy_as_device: " "cy_as_misc_register_callback failed. " "reason code: %d\n", ret); goto done; } ret = platform_driver_register(&west_bridge_driver); if (unlikely(ret < 0)) return ret; westbridge_pd = platform_device_register_simple( "west_bridge_dev", -1, NULL, 0); if (IS_ERR(westbridge_pd)) { platform_driver_unregister(&west_bridge_driver); return PTR_ERR(westbridge_pd); } /* Load the firmware */ ret = request_firmware(&fw_entry, "west bridge fw", &westbridge_pd->dev); if (ret) { cy_as_hal_print_message("cy_as_device: " "request_firmware failed return val = %d\n", ret); } else { cy_as_hal_print_message("cy_as_device: " "got the firmware %d size=0x%x\n", ret, fw_entry->size); ret = cy_as_misc_download_firmware( cy_as_dev->dev_handle, fw_entry->data, fw_entry->size , 0, 0); } if (ret != CY_AS_ERROR_SUCCESS) { cy_as_hal_print_message("<1>_cy_as_device: cannot download " "firmware. reason code: %d\n", ret); goto done; } /* spin until the device init is completed */ /* 50 -MAX wait time for the FW load & init * to complete is 5sec*/ spin_lim = 50; cy_as_hal_create_sleep_channel(&channel); while (!cy_as_device_init_done) { cy_as_hal_sleep_on(&channel, 100); if (spin_lim-- <= 0) { cy_as_hal_print_message( "<1>\n_e_r_r_o_r!: " "wait for FW init has timed out !!!"); break; } } cy_as_hal_destroy_sleep_channel(&channel); if (spin_lim > 0) cy_as_hal_print_message( "cy_as_device: astoria firmware is loaded\n"); ret = cy_as_misc_get_firmware_version(cy_as_dev->dev_handle, &ver_data, 0, 0); if (ret != CY_AS_ERROR_SUCCESS) { cy_as_hal_print_message("<1>_cy_as_device: cannot get firmware " "version. reason code: %d\n", ret); goto done; } if ((ver_data.media_type & 0x01) && (ver_data.media_type & 0x06)) str = "nand and SD/MMC."; else if ((ver_data.media_type & 0x01) && (ver_data.media_type & 0x08)) str = "nand and CEATA."; else if (ver_data.media_type & 0x01) str = "nand."; else if (ver_data.media_type & 0x08) str = "CEATA."; else str = "SD/MMC."; cy_as_hal_print_message("<1> cy_as_device:_firmware version: %s " "major=%d minor=%d build=%d,\n_media types supported:%s\n", ((ver_data.is_debug_mode) ? "debug" : "release"), ver_data.major, ver_data.minor, ver_data.build, str); spin_lock_init(&cy_as_dev->common_lock); /* done now */ cy_as_device_controller = cy_as_dev; return 0; done: if (cy_as_dev) cyasdevice_deinit(cy_as_dev); return -EINVAL; }
/* west bridge device driver main init */ static int cyasdevice_initialize(void) { cyasdevice *cy_as_dev = 0; int ret = 0; int retval = 0; cy_as_device_config config; cy_as_hal_sleep_channel channel; cy_as_get_firmware_version_data ver_data = {0}; const char *str = ""; int spin_lim; const struct firmware *fw_entry; cy_as_device_init_done = 0; cy_as_misc_set_log_level(8); cy_as_hal_print_message("<1>_cy_as_device initialize called\n"); if (cy_as_device_controller != 0) { cy_as_hal_print_message("<1>_cy_as_device: the device " "has already been initilaized. ignoring\n"); return -EBUSY; } /* cy_as_dev = CyAsHalAlloc (sizeof(cyasdevice), SLAB_KERNEL); */ cy_as_dev = cy_as_hal_alloc(sizeof(cyasdevice)); if (cy_as_dev == NULL) { cy_as_hal_print_message("<1>_cy_as_device: " "memory allocation failed\n"); return -ENOMEM; } memset(cy_as_dev, 0, sizeof(cyasdevice)); /* Init the HAL & CyAsDeviceHandle */ #ifdef CONFIG_MACH_OMAP3_WESTBRIDGE_AST_PNAND_HAL /* start OMAP HAL init instsnce */ if (!start_o_m_a_p_kernel(dev_handle_name, &(cy_as_dev->hal_tag), cy_false)) { cy_as_hal_print_message( "<1>_cy_as_device: start OMAP34xx HAL failed\n"); goto done; } #endif #ifdef CONFIG_MACH_C110_WESTBRIDGE_AST_PNAND_HAL /* start C110 HAL init instsnce */ if (!cy_as_hal_c110_pnand_start(dev_handle_name, &(cy_as_dev->hal_tag), cy_false)) { cy_as_hal_print_message("<1>_cy_as_device: start C110 HAL failed\n") ; goto done; } #endif /* Now create the device */ if (cy_as_misc_create_device(&(cy_as_dev->dev_handle), cy_as_dev->hal_tag) != CY_AS_ERROR_SUCCESS) { cy_as_hal_print_message( "<1>_cy_as_device: create device failed\n"); goto done; } memset(&config, 0, sizeof(config)); config.dmaintr = cy_true; ret = cy_as_misc_configure_device(cy_as_dev->dev_handle, &config); if (ret != CY_AS_ERROR_SUCCESS) { cy_as_hal_print_message( "<1>_cy_as_device: configure device " "failed. reason code: %d\n", ret); goto done; } ret = cy_as_misc_register_callback(cy_as_dev->dev_handle, cy_misc_callback); if (ret != CY_AS_ERROR_SUCCESS) { cy_as_hal_print_message("<1>_cy_as_device: " "cy_as_misc_register_callback failed. " "reason code: %d\n", ret); goto done; } ret = platform_driver_register(&west_bridge_driver); if (unlikely(ret < 0)) return ret; westbridge_pd = platform_device_register_simple( "west_bridge_dev", -1, NULL, 0); if (IS_ERR(westbridge_pd)) { cy_as_hal_print_message("[%s] error in register the platform\ driver for west bridge\n", __FUNCTION__); platform_driver_unregister(&west_bridge_driver); return PTR_ERR(westbridge_pd); } else {
int cy_as_diagnostics(cy_as_diag_cmd_type mode, char *result) { uint32_t retVal = 0; #ifdef __CYAS_SYSFS_FOR_DIAGNOSTICS__ cy_as_device_handle cyas_hd = cyasdevice_getdevhandle(); switch( mode ) { case CY_AS_DIAG_GET_VERSION: { cy_as_get_firmware_version_data ver_data = {0}; const char *str = "" ; cyasdevice_leave_standby(); retVal = cy_as_misc_get_firmware_version(cyas_hd, &ver_data, 0, 0) ; if (retVal != CY_AS_ERROR_SUCCESS) { cy_as_hal_print_message("cy_as_diagnostics: cannot get firmware version. reason code: %d\n", retVal) ; sprintf( result, "fail - %d", retVal ); return retVal; } if ((ver_data.media_type & 0x01) && (ver_data.media_type & 0x06)) str = "nand and SD/MMC." ; else if ((ver_data.media_type & 0x01) && (ver_data.media_type & 0x08)) str = "nand and CEATA." ; else if (ver_data.media_type & 0x01) str = "nand." ; else if (ver_data.media_type & 0x08) str = "CEATA." ; else str = "SD/MMC." ; cyasdevice_enter_standby(); cy_as_hal_print_message("<1> cy_as_device:_firmware version: %s " "major=%d minor=%d build=%d,\n_media types supported:%s\n", ((ver_data.is_debug_mode) ? "debug" : "release"), ver_data.major, ver_data.minor, ver_data.build, str) ; sprintf( result, "%d.%d.%d", ver_data.major, ver_data.minor, ver_data.build ); } break; case CY_AS_DIAG_DISABLE_MSM_SDIO: break; case CY_AS_DIAG_ENABLE_MSM_SDIO: break; case CY_AS_DIAG_ENTER_STANDBY: cyasdevice_enter_standby(); break; case CY_AS_DIAG_LEAVE_STANDBY: cyasdevice_leave_standby(); break; case CY_AS_DIAG_CREATE_BLKDEV: retVal = cyasblkdev_blk_init(0, 0); break; case CY_AS_DIAG_DESTROY_BLKDEV: cyasblkdev_blk_exit(); break; case CY_AS_DIAG_SD_MOUNT: { int i; uint32_t count = 0 ; int bus = 1 ; cy_as_storage_query_device_data dev_data ; cy_as_storage_query_unit_data unit_data = {0} ; cyasdevice_leave_standby(); actdata = (uint8_t *)cy_as_hal_alloc(CYASSTORAGE_MAX_XFER_SIZE); expdata = (uint8_t *)cy_as_hal_alloc(CYASSTORAGE_MAX_XFER_SIZE); cy_as_hal_mem_set(actdata, 0, CYASSTORAGE_MAX_XFER_SIZE); cy_as_hal_mem_set(expdata, 0, CYASSTORAGE_MAX_XFER_SIZE); retVal = cy_as_storage_device_control(cyas_hd, bus, 0, cy_true, cy_false, cy_as_storage_detect_SDAT_3, 0, 0) ; if (retVal != CY_AS_ERROR_SUCCESS) { cy_as_hal_print_message(KERN_ERR"ERROR: Cannot set Device control - Reason code %d\n", retVal) ; return retVal; } // Start the storage API and get a handle to the device we are interested in. retVal = cy_as_storage_start(cyas_hd,0,0) ; if (retVal != CY_AS_ERROR_SUCCESS) { cy_as_hal_print_message(KERN_ERR"ERROR: Cannot start storage stack - Reason code %d\n", retVal) ; return retVal; } retVal = cy_as_storage_query_media(cyas_hd, cy_as_media_sd_flash, &count, 0, 0) ; if (retVal != CY_AS_ERROR_SUCCESS) { cy_as_hal_print_message(KERN_ERR"ERROR: Cannot query SD device count - Reason code %d\n", retVal) ; return retVal; } if (!count) { cy_as_hal_print_message(KERN_ERR"ERROR: SD storage media was not found\n") ; return retVal; } else { cy_as_hal_print_message(KERN_ERR"SUCCESS: %d SD device(s) found. SD_CLK, SD_CMD, and SD_D0 connected\n", count) ; dev_data.bus = 1 ; dev_data.device = 0 ; retVal = cy_as_storage_query_device(cyas_hd, &dev_data, 0, 0 ); if(retVal != CY_AS_ERROR_SUCCESS) { cy_as_hal_print_message(KERN_ERR"ERROR: Cannot query SD device count - Reason code %d\n", retVal) ; return retVal; } else { #if 1 //skkm retVal = cy_as_storage_change_sd_frequency(cyas_hd, bus, 0x11, 24, 0, 0); if(retVal != CY_AS_ERROR_SUCCESS) { cy_as_hal_print_message("%s: Cannot control cy_as_storage_change_sd_frequency - reason [%d]\n", __func__, retVal) ; } #endif cy_as_hal_print_message(KERN_ERR"Checking for SD_WP Connectivity:\n"); if(dev_data.desc_p.writeable) { cy_as_hal_print_message(KERN_ERR" SD media is not write protected \n") ; } else { cy_as_hal_print_message(KERN_ERR" SD media is write protected %d\n", retVal) ; } unit_data.device = 0 ; unit_data.unit = 0 ; unit_data.bus = bus; retVal = cy_as_storage_query_unit(cyas_hd,&unit_data, 0, 0) ; if (retVal != CY_AS_ERROR_SUCCESS) { #ifndef WESTBRIDGE_NDEBUG cy_as_hal_print_message(KERN_INFO"%s: cannot query %d device unit - reason code %d\n", __func__, unit_data.bus, retVal) ; #endif return retVal; } } } cy_as_hal_set_ep_dma_mode(4, false); cy_as_hal_set_ep_dma_mode(8, false); start_unit = unit_data.desc_p.unit_size - MAX_DRQ_LOOPS_IN_ISR*2; for ( i = 0 ; i < CYASSTORAGE_MAX_XFER_SIZE ; i++ ) { expdata[i] = i; } } break; case CY_AS_DIAG_SD_READ: { int i; int bus = 1 ; struct timespec mStartTime, mEndTime; long second,nano; long mDelta; mStartTime = CURRENT_TIME; retVal = cy_as_storage_read(cyas_hd, bus, 0, 0, start_unit, actdata, MAX_DRQ_LOOPS_IN_ISR) ; if (retVal != CY_AS_ERROR_SUCCESS) { cy_as_hal_print_message(KERN_ERR "ERROR: cannot read from block device - code %d\n", retVal) ; break; } mEndTime = CURRENT_TIME; second = mEndTime.tv_sec - mStartTime.tv_sec; nano = mEndTime.tv_nsec - mStartTime.tv_nsec; mDelta = (second*1000000) + nano/1000; cy_as_hal_print_message("<1>%s: reading speed = %d KByte/s\n", __func__, (int)((CYASSTORAGE_MAX_XFER_SIZE*1000)/mDelta) ) ; if ( memcmp(expdata, actdata, 2048) != 0 ) { int errCnt = 0 ; cy_as_hal_print_message(KERN_ERR "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n") ; for ( i = 0 ; i < 2048 ; i++ ) { if ( expdata[i] != actdata[i] ) { cy_as_hal_print_message(KERN_ERR "EXP[%d]: 0x%02x\n",i, expdata[i]); cy_as_hal_print_message(KERN_ERR "ACT[%d]: 0x%02x\n",i, actdata[i]); errCnt++ ; if ( errCnt > 10 ) { break; } } } cy_as_hal_print_message(KERN_ERR "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n") ; retVal = CY_AS_ERROR_INVALID_RESPONSE; break; } else { cy_as_hal_print_message(KERN_ERR "success : storage test\n") ; } } break; case CY_AS_DIAG_SD_WRITE: { int i; int bus = 1 ; struct timespec mStartTime, mEndTime; long second,nano; long mDelta; for ( i = 0 ; i < CYASSTORAGE_MAX_XFER_SIZE ; i++ ) { expdata[i] = i; } mStartTime = CURRENT_TIME; retVal = cy_as_storage_write(cyas_hd, bus, 0, 0, start_unit, expdata, MAX_DRQ_LOOPS_IN_ISR) ; if (retVal != CY_AS_ERROR_SUCCESS) { cy_as_hal_print_message(KERN_ERR "ERROR: cannot write to block device - code %d\n", retVal) ; break; } mEndTime = CURRENT_TIME; second = mEndTime.tv_sec - mStartTime.tv_sec; nano = mEndTime.tv_nsec - mStartTime.tv_nsec; mDelta = (second*1000000) + nano/1000; cy_as_hal_print_message("<1>%s: writing speed = %d KByte/s\n", __func__, (int)((CYASSTORAGE_MAX_XFER_SIZE*1000)/mDelta) ) ; } break; case CY_AS_DIAG_SD_UNMOUNT: cy_as_hal_set_ep_dma_mode(4, true); cy_as_hal_set_ep_dma_mode(8, true); // Start the storage API and get a handle to the device we are interested in. retVal = cy_as_storage_stop(cyas_hd,0,0) ; if (retVal != CY_AS_ERROR_SUCCESS) { cy_as_hal_print_message(KERN_ERR"ERROR: Cannot stop storage stack - Reason code %d\n", retVal) ; return retVal; } cy_as_hal_free(actdata); cy_as_hal_free(expdata); cyasdevice_enter_standby(); break; #if 0 case CY_AS_DIAG_CONNECT_UMS: cyasdevice_leave_standby(); //cyasblkdev_blk_exit(); cyasdevice_reload_firmware(0); //CyAsHalSelUSBSwitch(1); retVal = CyAsAPIUsbInit(); if (retVal) { cy_as_hal_print_message("%s: USB test failed.\n", __func__) ; return 0; } else { msleep(1000); cy_as_hal_print_message("%s: USB connected.\n", __func__) ; } cy_as_hal_print_message("%s: UMS MODE init done\n", __func__) ; break; case CY_AS_DIAG_DISCONNECT_UMS: CyAsAPIUsbExit(); //CyAsHalSelUSBSwitch(0); cy_as_hal_print_message("%s: UMS mode - close done\n", __func__) ; cyasdevice_reload_firmware(1); //cyasblkdev_blk_init(0, 0); cyasdevice_enter_standby(); cy_as_hal_print_message("%s: reload F/W - close done\n", __func__) ; break; case CY_AS_DIAG_CONNECT_MTP: cyasdevice_leave_standby(); //CyAsHalSelUSBSwitch(1); cyasblkdev_blk_init(0, 0); retVal = cy_as_gadget_init(1); if (retVal) { cy_as_hal_print_message("%s: cy_as_gadget_init failed.\n", __func__) ; } else { cy_as_hal_print_message("%s: cy_as_gadget_init success\n", __func__) ; } cy_as_hal_print_message("%s: Start cy_as_gadget driver - init done\n", __func__) ; break; case CY_AS_DIAG_DISCONNECT_MTP: cyasblkdev_blk_exit(); cy_as_gadget_cleanup(); //CyAsHalSelUSBSwitch(0); cyasdevice_enter_standby(); cy_as_hal_print_message("%s: cy_as_gadget driver - close done\n", __func__) ; break; #endif case CY_AS_DIAG_TEST_RESET_LOW: //cy_as_hal_set_reset_pin(0); cy_as_hal_print_message("%s: cy_as_hal_set_reset_pin - set LOW\n", __func__) ; break; case CY_AS_DIAG_TEST_RESET_HIGH: //cy_as_hal_set_reset_pin(1); cy_as_hal_print_message("%s: cy_as_hal_set_reset_pin - set HIGH\n", __func__) ; break; default: cy_as_hal_print_message("%s: unkown mode \n", __func__) ; break; } #endif return retVal; }
/* * CyAsDmaStart() * * This function intializes the DMA module to insure it is up and running. */ cy_as_return_status_t cy_as_dma_start(cy_as_device *dev_p) { cy_as_end_point_number_t i ; uint16_t cnt ; if (cy_as_device_is_dma_running(dev_p)) return CY_AS_ERROR_ALREADY_RUNNING ; /* * pre-allocate DMA queue structures to be used in the interrupt context */ for (cnt = 0 ; cnt < 32 ; cnt++) { cy_as_dma_queue_entry *entry_p = (cy_as_dma_queue_entry *) cy_as_hal_alloc(sizeof(cy_as_dma_queue_entry)) ; if (entry_p == 0) { cy_as_dma_stop_internal(dev_p) ; return CY_AS_ERROR_OUT_OF_MEMORY ; } cy_as_dma_add_request_to_free_queue(dev_p, entry_p) ; } /* * pre-allocate the DMA requests for sending EP0 * and EP1 data to west bridge */ dev_p->usb_ep0_dma_req = cy_as_ll_create_request(dev_p, CY_RQT_USB_EP_DATA, CY_RQT_USB_RQT_CONTEXT, 64) ; dev_p->usb_ep1_dma_req = cy_as_ll_create_request(dev_p, CY_RQT_USB_EP_DATA, CY_RQT_USB_RQT_CONTEXT, 64) ; if (dev_p->usb_ep0_dma_req == 0 || dev_p->usb_ep1_dma_req == 0) { cy_as_dma_stop_internal(dev_p) ; return CY_AS_ERROR_OUT_OF_MEMORY ; } dev_p->usb_ep0_dma_req_save = dev_p->usb_ep0_dma_req ; dev_p->usb_ep0_dma_resp = cy_as_ll_create_response(dev_p, 1) ; dev_p->usb_ep1_dma_resp = cy_as_ll_create_response(dev_p, 1) ; if (dev_p->usb_ep0_dma_resp == 0 || dev_p->usb_ep1_dma_resp == 0) { cy_as_dma_stop_internal(dev_p) ; return CY_AS_ERROR_OUT_OF_MEMORY ; } dev_p->usb_ep0_dma_resp_save = dev_p->usb_ep0_dma_resp ; /* * set the dev_p->endp to all zeros to insure cleanup is possible if * an error occurs during initialization. */ cy_as_hal_mem_set(dev_p->endp, 0, sizeof(dev_p->endp)) ; /* * now, iterate through each of the endpoints and initialize each * one. */ for (i = 0 ; i < sizeof(dev_p->endp)/sizeof(dev_p->endp[0]) ; i++) { dev_p->endp[i] = (cy_as_dma_end_point *) cy_as_hal_alloc(sizeof(cy_as_dma_end_point)) ; if (dev_p->endp[i] == 0) { cy_as_dma_stop_internal(dev_p) ; return CY_AS_ERROR_OUT_OF_MEMORY ; } cy_as_hal_mem_set(dev_p->endp[i], 0, sizeof(cy_as_dma_end_point)) ; dev_p->endp[i]->ep = i ; dev_p->endp[i]->queue_p = 0 ; dev_p->endp[i]->last_p = 0 ; cy_as_dma_set_drq(dev_p, i, cy_false) ; if (!cy_as_hal_create_sleep_channel(&dev_p->endp[i]->channel)) return CY_AS_ERROR_CREATE_SLEEP_CHANNEL_FAILED ; } /* * tell the HAL layer who to call when the * HAL layer completes a DMA request */ cy_as_hal_dma_register_callback(dev_p->tag, cy_as_dma_completed_callback) ; /* * mark DMA as up and running on this device */ cy_as_device_set_dma_running(dev_p) ; return CY_AS_ERROR_SUCCESS ; }
/* * init OMAP h/w resources */ int cy_as_hal_omap_cram_start(const char *pgm, cy_as_hal_device_tag *tag, cy_bool debug) { cy_as_omap_dev_kernel *dev_p ; int i; u16 data16[4]; uint32_t err = 0; /* No debug mode support through argument as of now */ (void)debug; have_irq = false; /* * Initialize the HAL level endpoint DMA data. */ for (i = 0 ; i < sizeof(end_points)/sizeof(end_points[0]) ; i++) { end_points[i].data_p = 0 ; end_points[i].pending = cy_false ; end_points[i].size = 0 ; /* No debug mode support through argument as of now */ (void)debug; end_points[i].type = cy_as_hal_none ; end_points[i].sg_list_enabled = cy_false; /* * by default the DMA transfers to/from the E_ps don't * use sg_list that implies that the upper devices like * blockdevice have to enable it for the E_ps in their * initialization code */ } /* allocate memory for OMAP HAL*/ dev_p = (cy_as_omap_dev_kernel *)cy_as_hal_alloc( sizeof(cy_as_omap_dev_kernel)) ; if (dev_p == 0) { cy_as_hal_print_message("out of memory allocating OMAP" "device structure\n") ; return 0 ; } dev_p->m_sig = CY_AS_OMAP_CRAM_HAL_SIG; /* initialize OMAP hardware and StartOMAPKernelall gpio pins */ err = cy_as_hal_processor_hw_init(dev_p); if(err) goto bus_acc_error; /* * Now perform a hard reset of the device to have * the new settings take effect */ __gpio_set_value(AST_WAKEUP, 1); /* * do Astoria h/w reset */ DBGPRN(KERN_INFO"-_-_pulse -> westbridge RST pin\n"); /* * NEGATIVE PULSE on RST pin */ __gpio_set_value(AST_RESET, 0); mdelay(1); __gpio_set_value(AST_RESET, 1); mdelay(50); /* * NOTE: if you want to capture bus activity on the LA, * don't use printks in between the activities you want to capture. * prinks may take milliseconds, and the data of interest * will fall outside the LA capture window/buffer */ cy_as_hal_dump_reg((cy_as_hal_device_tag)dev_p); data16[0] = cy_as_hal_read_register((cy_as_hal_device_tag)dev_p, CY_AS_MEM_CM_WB_CFG_ID); if ( (data16[0]&0xA100 != 0xA100) || (data16[0]&0xA200 != 0xA200)) { /* * astoria device is not found */ printk(KERN_ERR "ERROR: astoria device is not found, " "CY_AS_MEM_CM_WB_CFG_ID %4.4x", data16[0]); goto bus_acc_error; } cy_as_hal_print_message(KERN_INFO" register access test:" "\n CY_AS_MEM_CM_WB_CFG_ID:%4.4x\n" "after cfg_wr:%4.4x\n\n", data16[0], data16[1]); dev_p->thread_flag = 1 ; spin_lock_init(&int_lock) ; dev_p->m_next_p = m_omap_list_p ; m_omap_list_p = dev_p ; *tag = dev_p; cy_as_hal_configure_interrupts((void *)dev_p); cy_as_hal_print_message(KERN_INFO"OMAP3430__hal started tag:%p" ", kernel HZ:%d\n", dev_p, HZ); /* *make processor to storage endpoints SG assisted by default */ cy_as_hal_set_ep_dma_mode(4, true); cy_as_hal_set_ep_dma_mode(8, true); return 1 ; /* * there's been a NAND bus access error or * astoria device is not connected */ bus_acc_error: /* * at this point hal tag hasn't been set yet * so the device will not call omap_stop */ cy_as_hal_omap_hardware_deinit(dev_p); cy_as_hal_free(dev_p) ; return 0; }