void start(void)
{
uint16_t count;
uint8_t index;
buffer = (char *)mos_mem_alloc((uint16_t)BUFFER_SIZE);
memset(buffer, 'X', BUFFER_SIZE);
/* For safety, erase entire FLASH */
dev_ioctl(DEV_TELOS_FLASH, TELOS_FLASH_BULK_ERASE);
/* Turn on the FLASH */
dev_mode(DEV_TELOS_FLASH, DEV_MODE_ON);
/* Acquire lock on FLASH and preliminarly
* write 64 bits of data */
dev_open(DEV_TELOS_FLASH);
count = dev_write(DEV_TELOS_FLASH, "abcdefgh", 8);
printf("%d bytes of data have been written to FLASH memory\n", count);
dev_close(DEV_TELOS_FLASH);
/* Perform experiments over R/W pointer to FLASH */
/* Experiment#1 - flash is on, lock is free; aquire lock and read
* without using any SEEK function */
dev_open(DEV_TELOS_FLASH);
count = dev_read(DEV_TELOS_FLASH, buffer, 1);
printf("#1 : %c has been read from FLASH memory\n", buffer[0]);
dev_close(DEV_TELOS_FLASH);
/* Move pointer */
dev_open(DEV_TELOS_FLASH);
dev_ioctl(DEV_TELOS_FLASH, DEV_SEEK, 3);
dev_close(DEV_TELOS_FLASH);
/* Experiment#2 - flash is on, lock is free; aquire lock, read single data,
* write single data and read multiple data from it */
dev_open(DEV_TELOS_FLASH);
dev_read(DEV_TELOS_FLASH, buffer, 1);
printf("#2 : %c has been read\n"
" : FLASH memory written\n", buffer[0]);
dev_write(DEV_TELOS_FLASH, "l", 1);
count = dev_read(DEV_TELOS_FLASH, buffer, 1);
printf(" : %d bytes have been read from FLASH memory: ", count);
for(index = 0; index < count; index++)
{
printf("%c ", buffer[index]);
}
printf("\n");
dev_close(DEV_TELOS_FLASH);
/* Release lock and free resources */
dev_close(DEV_TELOS_FLASH);
dev_mode(DEV_TELOS_FLASH, DEV_MODE_OFF);
mos_mem_free(buffer);
return;
}
inline
static int try_acquire_counter(void)
{
extern struct perf_counter_operations *perf_counter_ops;
extern u8 r5900_perf_mode;
int fd=-1;
if (r5900_perf_mode == PERF_MODE_SAMPLE){
return -EBUSY;
}
if (r5900_perf_mode == PERF_MODE_COUNTER) {
struct perf_dev_internal_cmd cmd_pkt;
void * taskp;
cmd_pkt.cmd = PERF_WRITER;
taskp = (void *) perf_counter_ops->control (0,
PERF_IOCINTERNAL, &cmd_pkt);
if (taskp == current) {
return 0;
}
return -EBUSY;
}
fd = dev_open("/dev/" PERF_DEV_COUNTER_NAME, O_RDWR, 0);
if (fd<0) {
return fd;
}
return 0;
}
/** Add the interface (net device) for a vnet.
* Sets the dev field of the vnet on success.
* Does nothing if the vnet already has an interface.
*
* @param vnet vnet
* @return 0 on success, error code otherwise
*/
int vnet_dev_add(Vnet *vnet){
int err = 0;
struct net_device *dev = NULL;
if(vnet->dev) goto exit;
vnet->header_n = ETH_HLEN + sizeof(struct iphdr) + sizeof(struct etheriphdr);
if(etherip_in_udp){
vnet->header_n += sizeof(struct VnetMsgHdr);
vnet->header_n += sizeof(struct udphdr);
}
vnet->header_n = roundupto(vnet->header_n, 4);
dev = alloc_netdev(0, vnet->device, vnet_dev_init);
if(!dev){
err = -ENOMEM;
goto exit;
}
err = vnet_dev_setup(vnet, dev);
if(err) goto exit;
rtnl_lock();
dev_open(dev);
rtnl_unlock();
exit:
return err;
}
BOOL ota_check(void)
{
ota_bl_info_t bl_info = {0};
charsto_cfg_t charsto_cfg = {0};
void *p_dev = NULL;
RET_CODE ret = ERR_FAILURE;
/******char storage init******/
ret = ATTACH_DRIVER(CHARSTO, warriors, default, default);
MT_ASSERT(ret == SUCCESS);
p_dev = dev_find_identifier(NULL, DEV_IDT_TYPE, SYS_DEV_TYPE_CHARSTO);
MT_ASSERT(NULL != p_dev);
charsto_cfg.size = CHARSTO_SIZE; //4
charsto_cfg.spi_clk = FLASH_C_CLK_P6;
charsto_cfg.rd_mode = SPI_FR_MODE;
//charsto_cfg.multi_io_rd = 1;
//charsto_cfg.multi_io_wd = 1;
ret = dev_open(p_dev, &charsto_cfg);
MT_ASSERT(ret == SUCCESS);
/* open uio */
uio_init();
mtos_task_delay_ms(M_TASK_DELAY_TIME);
if(mul_ota_dm_api_check_intact_picec(OTA_DM_BLOCK_PIECE_OTA_BLINFO_ID) == FALSE)
{
ui_ota_api_bootload_info_init();
}
mul_ota_dm_api_read_bootload_info(&bl_info);
OS_PRINTF("\r\n[OTA]%s:ota_tri[%d] ",__FUNCTION__, bl_info.ota_status);
/* flash burning is not finished, force ota*/
if( bl_info.destroy_flag == TRUE)
{
bl_info.ota_status = OTA_TRI_MODE_FORC;
mul_ota_dm_api_save_bootload_info(&bl_info);
return TRUE;
}
if(is_force_key_press())
{
bl_info.ota_status = OTA_TRI_MODE_AUTO;
mul_ota_dm_api_save_bootload_info(&bl_info);
return TRUE;
}
if((bl_info.ota_status == OTA_TRI_MODE_AUTO)
||(bl_info.ota_status == OTA_TRI_MODE_FORC))
{
return TRUE;
}
return FALSE;
}
static struct net_device *ipmr_reg_vif(void)
{
struct net_device *dev;
struct in_device *in_dev;
dev = alloc_netdev(sizeof(struct net_device_stats), "pimreg",
reg_vif_setup);
if (dev == NULL)
return NULL;
if (register_netdevice(dev)) {
free_netdev(dev);
return NULL;
}
dev->iflink = 0;
if ((in_dev = inetdev_init(dev)) == NULL)
goto failure;
in_dev->cnf.rp_filter = 0;
if (dev_open(dev))
goto failure;
return dev;
failure:
unregister_netdevice(dev);
return NULL;
}
/*****************************************************************************
* Open the "real" network devices. Return the number of opened interfaces.
*****************************************************************************/
int open_network_devices(int promisc)
{
struct net_device *dev;
struct net *net;
int err = 0, cnt = 0;
DEBUG(ANKH_DEBUG_INIT, "%s() \n", __func__);
for_each_net(net) {
for_each_netdev(net, dev)
{
DEBUG(ANKH_DEBUG_INIT, "opening %s\n", dev->name);
// beam us to promiscuous mode, so that we can receive packets that
// are not meant for the NIC's MAC address --> we need that, because
// ORe clients have different MAC addresses
if (promisc && netdev_set_promisc(dev) == 0)
DEBUG(ANKH_DEBUG_INIT, "set interface to promiscuous mode.\n");
err = dev_open(dev);
if (err)
{
DEBUG(ANKH_DEBUG_INIT, "error opening %s : %d\n", dev->name, err);
return err;
}
else // success
netdev_add(dev);
cnt++;
//xmit_lock_add(dev->name);
}
}
static struct net_device *ip6mr_reg_vif(struct net *net)
{
struct net_device *dev;
dev = alloc_netdev(0, "pim6reg", reg_vif_setup);
if (dev == NULL)
return NULL;
dev_net_set(dev, net);
if (register_netdevice(dev)) {
free_netdev(dev);
return NULL;
}
dev->iflink = 0;
if (dev_open(dev))
goto failure;
dev_hold(dev);
return dev;
failure:
/* allow the register to be completed before unregistering. */
rtnl_unlock();
rtnl_lock();
unregister_netdevice(dev);
return NULL;
}
/* Unused */
int label_verify(struct device *dev)
{
#pragma pack(8)
char buf[LABEL_SIZE];
#pragma pack()
struct labeller *l;
//char buf[LABEL_SIZE] __attribute((aligned(8)));
uint64_t sector;
struct lvmcache_info *info;
int r = 0;
if (!dev_open(dev)) {
if ((info = info_from_pvid(dev->pvid)))
lvmcache_update_vgname_and_id(info, ORPHAN, ORPHAN,
0, NULL);
return_0;
}
if (!(l = _find_labeller(dev, buf, §or, UINT64_C(0))))
goto_out;
r = l->ops->verify ? l->ops->verify(l, buf, sector) : 1;
out:
if (!dev_close(dev))
stack;
return r;
}
static struct net_device *ipmr_reg_vif(void)
{
struct net_device *dev;
struct in_device *in_dev;
dev = alloc_netdev(sizeof(struct net_device_stats), "pimreg",
reg_vif_setup);
if (dev == NULL)
return NULL;
if (register_netdevice(dev)) {
free_netdev(dev);
return NULL;
}
dev->iflink = 0;
if ((in_dev = inetdev_init(dev)) == NULL)
goto failure;
in_dev->cnf.rp_filter = 0;
if (dev_open(dev))
goto failure;
return dev;
failure:
/* allow the register to be completed before unregistering. */
rtnl_unlock();
rtnl_lock();
unregister_netdevice(dev);
return NULL;
}
void rds(char *arg)
{
int c;
char *val, err[0xff];
struct pcimaxfm_rds_set rds_set;
while (*arg != '\0') {
if ((c = (getsubopt(&arg, rds_params_name, &val))) == -1)
ERROR_MSG("Invalid RDS parameter \"%s\".", val);
if (validate_rds(c, val, sizeof(err), err)) {
ERROR_MSG("%s", err);
}
dev_open();
rds_set.param = c;
rds_set.value = val;
if(ioctl(fd, PCIMAXFM_RDS_SET, &rds_set) == -1) {
ERROR_MSG("Writing RDS parameter %s = \"%s\" failed.",
rds_params_name[rds_set.param],
rds_set.value);
}
NOTICE_MSG("RDS: %-4s = \"%s\"",
rds_params_name[rds_set.param], rds_set.value);
}
}
void power(const char *arg)
{
int power;
dev_open();
if (arg) {
if (sscanf(arg, "%u", &power) < 1) {
ERROR_MSG("Invalid power level. Got \"%s\", expected integer in the range of %d-%d.", arg, PCIMAXFM_POWER_MIN, PCIMAXFM_POWER_MAX);
}
if (power < PCIMAXFM_POWER_MIN || power > PCIMAXFM_POWER_MAX) {
ERROR_MSG("Power level out of range. Got %d, expected %d-%d.", power, PCIMAXFM_POWER_MIN, PCIMAXFM_POWER_MAX);
}
if (ioctl(fd, PCIMAXFM_POWER_SET, &power) == -1) {
ERROR_MSG("Setting power level failed.");
}
} else {
if (ioctl(fd, PCIMAXFM_POWER_GET, &power) == -1) {
ERROR_MSG("Reading power level failed.");
}
if (power == PCIMAXFM_POWER_NA) {
NOTICE_MSG("Power level not set yet.");
return;
}
}
NOTICE_MSG("Power level: %d/%d", power, PCIMAXFM_POWER_MAX);
}
int main (void)
{
unsigned int mainkey;
char buf[128] = {0,};
printf("Program Start...\n");
dev_fd = dev_open("/dev/webconn", WEBCONN_MAJOR, 0);
write(dev_fd, "khkrai", 128);
read(dev_fd, &buf, 128);
printf("\n\nbuf=%s\n", buf);
printf("%x\n", IOCTL_WRITE);
printf("%x\n", IOCTL_READ);
ioctl(dev_fd, IOCTL_WRITE, 1);
ioctl(dev_fd, IOCTL_READ, 0);
close(dev_fd);
return 0;
}
/* Called whenever someone tries to open our node (even for a stat). We
delay opening the kernel device until this point, as we can usefully
return errors from here. */
static error_t
check_open_hook (struct trivfs_control *trivfs_control,
struct iouser *user,
int flags)
{
struct dev *const dev = trivfs_control->hook;
error_t err = 0;
if (!err && dev_is_readonly (dev) && (flags & O_WRITE))
return EROFS;
mutex_lock (&dev->lock);
if (dev->store == NULL)
{
/* Try and open the store. */
err = dev_open (dev);
if (err && (flags & (O_READ|O_WRITE)) == 0)
/* If we're not opening for read or write, then just ignore the
error, as this allows stat to work correctly. XXX */
err = 0;
}
mutex_unlock (&dev->lock);
return err;
}
static
struct net_device *ipmr_new_tunnel(struct net *net, struct vifctl *v)
{
struct net_device *dev;
dev = __dev_get_by_name(net, "tunl0");
if (dev) {
const struct net_device_ops *ops = dev->netdev_ops;
int err;
struct ifreq ifr;
struct ip_tunnel_parm p;
struct in_device *in_dev;
memset(&p, 0, sizeof(p));
p.iph.daddr = v->vifc_rmt_addr.s_addr;
p.iph.saddr = v->vifc_lcl_addr.s_addr;
p.iph.version = 4;
p.iph.ihl = 5;
p.iph.protocol = IPPROTO_IPIP;
sprintf(p.name, "dvmrp%d", v->vifc_vifi);
ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
if (ops->ndo_do_ioctl) {
mm_segment_t oldfs = get_fs();
set_fs(KERNEL_DS);
err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL);
set_fs(oldfs);
} else
err = -EOPNOTSUPP;
dev = NULL;
if (err == 0 &&
(dev = __dev_get_by_name(net, p.name)) != NULL) {
dev->flags |= IFF_MULTICAST;
in_dev = __in_dev_get_rtnl(dev);
if (in_dev == NULL)
goto failure;
ipv4_devconf_setall(in_dev);
IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
if (dev_open(dev))
goto failure;
dev_hold(dev);
}
}
return dev;
failure:
/* allow the register to be completed before unregistering. */
rtnl_unlock();
rtnl_lock();
unregister_netdevice(dev);
return NULL;
}
void install_drivers() {
dev_t console;
// Register /proc/units
register_proc_inode("units", units_proc, NULL);
register_proc_inode("devices", devices_proc, NULL);
register_proc_inode("devstat", devstat_proc, NULL);
// Parse driver binding database
parse_bindings();
// Match bindings to units
bind_units();
// Install legacy drivers
install_legacy_drivers();
// Make sure we have a console device
console = dev_open("console");
if (console == NODEV) {
initialize_driver(NULL, "krnl.dll!console");
} else {
dev_close(console);
}
}
/* FIXME Avoid repeated re-reading if cache lock held */
int label_read(struct device *dev, struct label **result,
uint64_t scan_sector)
{
#pragma pack(8)
char buf[LABEL_SIZE]; //__attribute((aligned(8)));
#pragma pack()
struct labeller *l;
uint64_t sector;
struct lvmcache_info *info;
int r = 0;
if (!dev_open(dev)) {
stack;
if ((info = info_from_pvid(dev->pvid)))
lvmcache_update_vgname_and_id(info, ORPHAN, ORPHAN,
0, NULL);
return r;
}
if (!(l = _find_labeller(dev, buf, §or, scan_sector)))
goto_out;
if ((r = (l->ops->read)(l, dev, buf, result)) && result && *result)
(*result)->sector = sector;
out:
if (!dev_close(dev))
stack;
return r;
}
int DeviceV4L2Base::open_dev(int color_model)
{
v4l2_lock->lock("DeviceV4L2Base::open_dev");
int result = 0;
if( !opened )
{
result = dev_open();
if( !result )
result = v4l2_open(color_model);
if( !result )
result = start_dev();
if( !result )
{
qbfrs_lock->reset();
video_lock->reset();
getq = new DeviceV4L2BufferQ(total_buffers+1);
put_thread = new DeviceV4L2Put(this);
put_thread->start();
done = 0;
Thread::start();
}
else
printf("DeviceV4L2Base::open_dev failed\n");
}
if( result )
{
printf("DeviceV4L2Base::open_dev: adaptor open failed\n");
stop_dev();
dev_close();
}
else
opened = 1;
v4l2_lock->unlock();
return result;
}
struct netif *ether_netif_add(char *name, char *devname, struct ip_addr *ipaddr, struct ip_addr *netmask, struct ip_addr *gw) {
struct netif *netif;
struct dhcp_state *state;
dev_t devno;
// Open device
devno = dev_open(devname);
if (devno == NODEV) return NULL;
if (device(devno)->driver->type != DEV_TYPE_PACKET) return NULL;
// Attach device to network interface
netif = netif_add(name, ipaddr, netmask, gw);
if (!netif) return NULL;
netif->output = ether_output;
netif->state = (void *) devno;
dev_attach(devno, netif, ether_input);
// Obtain network parameters using DHCP
if (ip_addr_isany(ipaddr)) {
state = dhcp_start(netif);
if (state) {
if (wait_for_object(&state->binding_complete, 30000) < 0) {
kprintf(KERN_WARNING "ether: timeout waiting for dhcp to complete on %s\n", name);
}
}
}
kprintf(KERN_INFO "%s: device %s addr %a mask %a gw %a\n", name, devname, &netif->ipaddr, &netif->netmask, &netif->gw);
return netif;
}
static int _dev_read_ahead_dev(struct device *dev, uint32_t *read_ahead)
{
long read_ahead_long;
if (dev->read_ahead != -1) {
*read_ahead = (uint32_t) dev->read_ahead;
return 1;
}
if (!dev_open(dev))
return_0;
if (ioctl(dev->fd, BLKRAGET, &read_ahead_long) < 0) {
log_sys_error("ioctl BLKRAGET", dev_name(dev));
if (!dev_close(dev))
stack;
return 0;
}
if (!dev_close(dev))
stack;
*read_ahead = (uint32_t) read_ahead_long;
dev->read_ahead = read_ahead_long;
log_very_verbose("%s: read_ahead is %u sectors",
dev_name(dev), *read_ahead);
return 1;
}
static void fork_worker(struct init_action *a)
{
int fd;
pid_t p;
a->proc.pid = fork();
if (!a->proc.pid) {
p = setsid();
fd = dev_open(a->id);
if (fd != -1)
{
dup2(fd, STDIN_FILENO);
dup2(fd, STDOUT_FILENO);
dup2(fd, STDERR_FILENO);
if (fd > STDERR_FILENO)
close(fd);
}
ioctl(STDIN_FILENO, TIOCSCTTY, 1);
tcsetpgrp(STDIN_FILENO, p);
execvp(a->argv[0], a->argv);
ERROR("Failed to execute %s\n", a->argv[0]);
exit(-1);
}
if (a->proc.pid > 0) {
DEBUG(4, "Launched new %s action, pid=%d\n",
a->handler->name,
(int) a->proc.pid);
uloop_process_add(&a->proc);
}
}
static int _dev_discard_blocks(struct device *dev, uint64_t offset_bytes, uint64_t size_bytes)
{
uint64_t discard_range[2];
if (!dev_open(dev))
return_0;
discard_range[0] = offset_bytes;
discard_range[1] = size_bytes;
log_debug_devs("Discarding %" PRIu64 " bytes offset %" PRIu64 " bytes on %s.",
size_bytes, offset_bytes, dev_name(dev));
if (ioctl(dev->fd, BLKDISCARD, &discard_range) < 0) {
log_error("%s: BLKDISCARD ioctl at offset %" PRIu64 " size %" PRIu64 " failed: %s.",
dev_name(dev), offset_bytes, size_bytes, strerror(errno));
if (!dev_close(dev))
stack;
/* It doesn't matter if discard failed, so return success. */
return 1;
}
if (!dev_close(dev))
stack;
return 1;
}
void get_rssi()
{
uint16_t rssi_val;
dev_open(DEV_AVR_RSSI);
dev_read(DEV_AVR_RSSI, &rssi_val, sizeof(rssi_val));
dev_close(DEV_AVR_RSSI);
printf("rssi %d\n",rssi_val);
}
/* Open a connection to an IO device */
int io_dev_open(const io_dev_connector_t *dev_con, const uintptr_t dev_spec,
uintptr_t *handle)
{
int result;
assert(handle != NULL);
result = dev_open(dev_con, dev_spec, (io_dev_info_t **)handle);
return result;
}
bool FW_writeFlash(char *filename)
{
FILE *fp;
uint8_t *buf = 0;
uint32_t *buf32, chksum;
int i, filesize;
if ((fp = fopen(filename, "rb")) == 0) {
printf("unable to open firmware '%s'\n", filename);
return(false);
}
fseek(fp, 0, SEEK_END);
filesize = ftell(fp);
fseek(fp, 0, SEEK_SET);
if (filesize > (0x8000 - 8)) {
printf("firmware image too large\n");
fclose(fp);
return(false);
}
buf = (uint8_t*)malloc(0x8000);
buf32 = (uint32_t*)buf;
memset(buf, 0, 0x8000);
fread(buf, 1, filesize, fp);
fclose(fp);
buf32[(0x8000 - 8) / 4] = 0xDEADBEEF;
chksum = 0;
for (i = 0; i<(0x8000 - 4); i += 4) {
chksum ^= buf32[i / 4];
}
printf("firmware is %d bytes, checksum is $%08X\n", filesize, chksum);
buf32[(0x8000 - 4) / 4] = chksum;
printf("uploading new firmware");
if (!spi_writeFlash2(buf, 0x8000, 0x8000)) {
printf("Write failed.\n");
return false;
}
free(buf);
printf("waiting for device to reboot\n");
dev_updateFirmware(); //start update, device will reset itself
sleep_ms(5000);
if (!dev_open()) {
printf("Open failed.\n");
return false;
}
printf("Updated to build %d\n", dev_fwVersion);
return true;
}
static int dev_exist(const char *dev)
{
int res;
res = dev_open(dev);
if (res != -1)
close(res);
return (res != -1);
}
/*===========================================================================*
* fs_readsuper *
*===========================================================================*/
PUBLIC int fs_readsuper() {
cp_grant_id_t label_gid;
size_t label_len;
int r = OK;
endpoint_t driver_e;
int readonly;
fs_dev = fs_m_in.REQ_DEV;
label_gid = fs_m_in.REQ_GRANT;
label_len = fs_m_in.REQ_PATH_LEN;
readonly = 1; /* Always mount devices read only. */
if (label_len > sizeof(fs_dev_label))
return(EINVAL);
r = sys_safecopyfrom(fs_m_in.m_source, label_gid, 0, (vir_bytes)fs_dev_label,
label_len, D);
if (r != OK) {
printf("ISOFS %s:%d safecopyfrom failed: %d\n", __FILE__, __LINE__, r);
return(EINVAL);
}
r = ds_retrieve_label_endpt(fs_dev_label, &driver_e);
if (r != OK) {
printf("ISOFS %s:%d ds_retrieve_label_endpt failed for '%s': %d\n",
__FILE__, __LINE__, fs_dev_label, r);
return(EINVAL);
}
/* Map the driver endpoint for this major */
driver_endpoints[(fs_dev >> MAJOR) & BYTE].driver_e = driver_e;
/* Open the device the file system lives on */
if (dev_open(driver_e, fs_dev, driver_e,
readonly ? R_BIT : (R_BIT|W_BIT)) != OK) {
return(EINVAL);
}
/* Read the superblock */
r = read_vds(&v_pri, fs_dev);
if (r != OK)
return(r);
/* Return some root inode properties */
fs_m_out.RES_INODE_NR = ID_DIR_RECORD(v_pri.dir_rec_root);
fs_m_out.RES_MODE = v_pri.dir_rec_root->d_mode;
fs_m_out.RES_FILE_SIZE_LO = v_pri.dir_rec_root->d_file_size;
fs_m_out.RES_UID = SYS_UID; /* Always root */
fs_m_out.RES_GID = SYS_GID; /* operator */
fs_m_out.RES_CONREQS = 1; /* We can handle only 1 request at a time */
return(r);
}
void send_packet(uint8_t packet_id)
{
static uint8_t inited = 0;
uint16_t temp;
uint16_t hum;
if (!inited)
{
inited = 1;
dev_open(DEV_MSP_HUMIDITY);
if (dev_mode(DEV_MSP_HUMIDITY, DEV_MODE_ON) == DEV_FAILURE)
{
no_sensor = 1;
}
}
mos_mutex_lock(&send_mutex);
if (no_sensor)
{
temp = rand();
hum = rand();
}
else
{
dev_read(DEV_MSP_TEMPERATURE, &temp, sizeof(temp));
dev_read(DEV_MSP_HUMIDITY, &hum, sizeof(hum));
}
buf.size = 13;
buf.data[0] = packet_id;
buf_insert_WORD(buf.data, 1, mos_node_id_get());
buf_insert_WORD(buf.data, 3, temp);
buf_insert_WORD(buf.data, 5, hum);
if (no_sensor)
{
buf_insert_WORD(buf.data, 7, rand());
buf_insert_WORD(buf.data, 9, rand());
}
else
{
buf_insert_WORD(buf.data, 7, adc_get_conversion16(4));
buf_insert_WORD(buf.data, 9, adc_get_conversion16(5));
}
buf_insert_WORD(buf.data, 11, crc_compute(buf.data, 11));
com_send(IFACE_RADIO, &buf);
mos_mutex_unlock(&send_mutex);
}
/**
* hns_nic_self_test - self test
* @dev: net device
* @eth_test: test cmd
* @data: test result
*/
static void hns_nic_self_test(struct net_device *ndev,
struct ethtool_test *eth_test, u64 *data)
{
struct hns_nic_priv *priv = netdev_priv(ndev);
bool if_running = netif_running(ndev);
#define SELF_TEST_TPYE_NUM 3
int st_param[SELF_TEST_TPYE_NUM][2];
int i;
int test_index = 0;
st_param[0][0] = MAC_INTERNALLOOP_MAC; /* XGE not supported lb */
st_param[0][1] = (priv->ae_handle->phy_if != PHY_INTERFACE_MODE_XGMII);
st_param[1][0] = MAC_INTERNALLOOP_SERDES;
st_param[1][1] = 1; /*serdes must exist*/
st_param[2][0] = MAC_INTERNALLOOP_PHY; /* only supporte phy node*/
st_param[2][1] = ((!!(priv->ae_handle->phy_dev)) &&
(priv->ae_handle->phy_if != PHY_INTERFACE_MODE_XGMII));
if (eth_test->flags == ETH_TEST_FL_OFFLINE) {
set_bit(NIC_STATE_TESTING, &priv->state);
if (if_running)
dev_close(ndev);
for (i = 0; i < SELF_TEST_TPYE_NUM; i++) {
if (!st_param[i][1])
continue; /* NEXT testing */
data[test_index] = __lb_up(ndev,
(enum hnae_loop)st_param[i][0]);
if (!data[test_index]) {
data[test_index] = __lb_run_test(
ndev, (enum hnae_loop)st_param[i][0]);
(void)__lb_down(ndev,
(enum hnae_loop)st_param[i][0]);
}
if (data[test_index])
eth_test->flags |= ETH_TEST_FL_FAILED;
test_index++;
}
hns_nic_net_reset(priv->netdev);
clear_bit(NIC_STATE_TESTING, &priv->state);
if (if_running)
(void)dev_open(ndev, NULL);
}
/* Online tests aren't run; pass by default */
(void)msleep_interruptible(4 * 1000);
}
void spiflash_cfg( )
{
RET_CODE ret;
void *p_dev = NULL;
void *p_spi = NULL;
charsto_cfg_t charsto_cfg = {0};
spi_cfg_t spiCfg;
spiCfg.bus_clk_mhz = 50;//10;
spiCfg.bus_clk_delay = 12;//8;
spiCfg.io_num = 1;
spiCfg.lock_mode = OS_MUTEX_LOCK;
spiCfg.op_mode = 0;
spiCfg.pins_cfg[0].miso1_src = 0;
spiCfg.pins_cfg[0].miso0_src = 1;
spiCfg.pins_cfg[0].spiio1_src = 0;
spiCfg.pins_cfg[0].spiio0_src = 0;
spiCfg.pins_dir[0].spiio1_dir = 3;
spiCfg.pins_dir[0].spiio0_dir = 3;
spiCfg.spi_id = 0;
ret = spi_concerto_attach("spi_concerto_0");
MT_ASSERT(SUCCESS == ret);
p_spi = dev_find_identifier(NULL,DEV_IDT_NAME, (u32)"spi_concerto_0");
spiCfg.spi_id = 0;
ret = dev_open(p_spi, &spiCfg);
MT_ASSERT(SUCCESS == ret);
spiflash_jazz_attach("charsto_concerto");
OS_PRINTF("drv --charsto 1\n");
p_dev = dev_find_identifier(NULL, DEV_IDT_TYPE, SYS_DEV_TYPE_CHARSTO);
MT_ASSERT(NULL != p_dev);
OS_PRINTF("drv --charsto 2\n");
charsto_cfg.rd_mode = SPI_FR_MODE;
charsto_cfg.p_bus_handle = p_spi;
charsto_cfg.size = CHARSTO_SIZE;
ret = dev_open(p_dev, &charsto_cfg);
MT_ASSERT(SUCCESS == ret);
}
/*
* Set destination address.
* Special case for SIT interfaces where we create a new "virtual"
* device.
*/
int addrconf_set_dstaddr(void *arg)
{
struct in6_ifreq ireq;
struct device *dev;
int err = -EINVAL;
rtnl_lock();
err = -EFAULT;
if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
goto err_exit;
dev = dev_get_by_index(ireq.ifr6_ifindex);
err = -ENODEV;
if (dev == NULL)
goto err_exit;
if (dev->type == ARPHRD_SIT) {
struct ifreq ifr;
mm_segment_t oldfs;
struct ip_tunnel_parm p;
err = -EADDRNOTAVAIL;
if (!(ipv6_addr_type(&ireq.ifr6_addr) & IPV6_ADDR_COMPATv4))
goto err_exit;
memset(&p, 0, sizeof(p));
p.iph.daddr = ireq.ifr6_addr.s6_addr32[3];
p.iph.saddr = 0;
p.iph.version = 4;
p.iph.ihl = 5;
p.iph.protocol = IPPROTO_IPV6;
p.iph.ttl = 64;
ifr.ifr_ifru.ifru_data = (void*)&p;
oldfs = get_fs();
set_fs(KERNEL_DS);
err = dev->do_ioctl(dev, &ifr, SIOCADDTUNNEL);
set_fs(oldfs);
if (err == 0) {
err = -ENOBUFS;
if ((dev = dev_get(p.name)) == NULL)
goto err_exit;
err = dev_open(dev);
}
}
err_exit:
rtnl_unlock();
return err;
}
