/*
** ping a serial device
*/
void ping_command(char *name, char *response) {
int ii, limit;
SERIAL_DEVICE_PTR device;
char log_message[MAX_LOG_MESSAGE];
assert(name != (char *) NULL);
assert(response != (char *) NULL);
//remove control characters (if any)
limit = strlen(name);
for (ii = 0; ii < limit; ii++) {
if (iscntrl(name[ii])) {
name[ii] = '\0';
}
}
device = get_device_by_name(name);
if (device == NULL) {
sprintf(log_message, "%s:%s", RESPONSE_BAD_DEVICE, name);
log_error(__FILE__, __LINE__, log_message);
strcpy(response, RESPONSE_BAD_DEVICE);
return;
}
device_service(device, PING_COMMAND, NULL, response);
}
static int rdu_networkconfig(void)
{
static char *rdu_netconfig;
struct device_d *sp_dev;
if (!of_machine_is_compatible("zii,imx6q-zii-rdu2") &&
!of_machine_is_compatible("zii,imx6qp-zii-rdu2") &&
!of_machine_is_compatible("zii,imx51-rdu1"))
return 0;
sp_dev = get_device_by_name("sp");
if (!sp_dev) {
pr_warn("no sp device found, network config not available!\n");
return -ENODEV;
}
rdu_netconfig = basprintf("ip=%s:::%s::eth0:",
dev_get_param(sp_dev, "ipaddr"),
dev_get_param(sp_dev, "netmask"));
globalvar_add_simple_string("linux.bootargs.rdu_network",
&rdu_netconfig);
return 0;
}
/*
** return auto update port assignment
*/
void auto_update_command(char *name, char *response) {
int ii, limit;
SERIAL_DEVICE_PTR device;
char log_message[MAX_LOG_MESSAGE];
assert(name != (char *) NULL);
assert(response != (char *) NULL);
//remove control characters (if any)
limit = strlen(name);
for (ii = 0; ii < limit; ii++) {
if (iscntrl(name[ii])) {
name[ii] = '\0';
}
}
device = get_device_by_name(name);
if (device == NULL) {
sprintf(log_message, "%s:%s", RESPONSE_BAD_DEVICE, name);
log_error(__FILE__, __LINE__, log_message);
strcpy(response, RESPONSE_BAD_DEVICE);
return;
}
sprintf(response, "%s/%s/%d/%d", PROTO_KEY_AUTO_UPDATE, device->name, device->update_descriptor, device->update_port);
}
int set_printer_by_name(GraceApp *gapp, const char *dname)
{
Canvas *canvas = grace_get_canvas(gapp->grace);
int device;
device = get_device_by_name(canvas, dname);
return set_printer(gapp, device);
}
static int do_detect(int argc, char *argv[])
{
struct device_d *dev;
int opt, i, ret;
int option_list = 0;
int option_error = 0;
int option_all = 0;
while ((opt = getopt(argc, argv, "ela")) > 0) {
switch (opt) {
case 'l':
option_list = 1;
break;
case 'e':
option_error = 1;
break;
case 'a':
option_all = 1;
break;
default:
return COMMAND_ERROR_USAGE;
}
}
if (option_list) {
for_each_device(dev) {
if (dev->detect)
printf("%s\n", dev_name(dev));
}
return 0;
}
if (option_all) {
for_each_device(dev) {
ret = device_detect(dev);
if (ret && ret != -ENOSYS && option_error)
return ret;
}
return 0;
}
if (argc == optind)
return COMMAND_ERROR_USAGE;
for (i = optind; i < argc; i++) {
dev = get_device_by_name(argv[i]);
if (!dev)
return -ENODEV;
ret = device_detect(dev);
if (ret && option_error)
return ret;
}
return 0;
}
/*
** validate command and dispatch for processing
*/
void device_command(char *name, char *command, char *argument, char *response) {
int ii, limit;
SERIAL_DEVICE_PTR device;
char log_message[MAX_LOG_MESSAGE];
assert(name != (char *) NULL);
assert(command != (char *) NULL);
assert(argument != (char *) NULL);
assert(response != (char *) NULL);
//remove control characters (if any)
limit = strlen(name);
for (ii = 0; ii < limit; ii++) {
if (iscntrl(name[ii])) {
name[ii] = '\0';
}
}
device = get_device_by_name(name);
if (device == NULL) {
sprintf(log_message, "%s:%s", RESPONSE_BAD_DEVICE, name);
log_error(__FILE__, __LINE__, log_message);
strcpy(response, RESPONSE_BAD_DEVICE);
return;
}
//remove control characters (if any)
limit = strlen(command);
for (ii = 0; ii < limit; ii++) {
if (iscntrl(command[ii])) {
command[ii] = '\0';
}
}
SERIAL_COMMAND_TYPE sct = utility_map_serial_command(command);
if (sct == UNKNOWN_COMMAND) {
sprintf(log_message, "%s:%s", RESPONSE_BAD_COMMAND, command);
log_error(__FILE__, __LINE__, log_message);
strcpy(response, RESPONSE_BAD_COMMAND);
return;
}
//remove control characters (if any)
limit = strlen(argument);
for (ii = 0; ii < limit; ii++) {
if (iscntrl(argument[ii])) {
argument[ii] = '\0';
}
}
device_service(device, sct, argument, response);
}
void parse_cmdline(int argc, char **argv) {
char c;
memset(&cmdopts, 0, sizeof(cmdopts));
while((c = getopt(argc, argv, "leuPvyqr:w:p:c:iI")) != -1) {
switch(c) {
case 'l':
print_devices_and_exit();
break;
case 'e':
cmdopts.erase=1; // 1= do not erase
break;
case 'u':
cmdopts.protect_off=1; // 1= do not disable write protect
break;
case 'P':
cmdopts.protect_on=1; // 1= do not enable write protect
break;
case 'v':
cmdopts.verify=1; // 1= do not verify
break;
case 'y':
cmdopts.idcheck_continue=1; // 1= do not stop on id mismatch
break;
case 'p':
if(!strcmp(optarg, "help"))
print_devices_and_exit();
cmdopts.device = get_device_by_name(optarg);
if(!cmdopts.device)
ERROR("Unknown device");
break;
case 'c':
if(!strcmp(optarg, "code"))
cmdopts.page = CODE;
if(!strcmp(optarg, "data"))
cmdopts.page = DATA;
if(!strcmp(optarg, "config"))
cmdopts.page = CONFIG;
if(!cmdopts.page)
ERROR("Unknown memory type");
break;
case 'q':
cmdopts.query_device_id=8; // 8= query for 8 bit device id
cmdopts.device = get_device_by_name("M25P80 @SOIC8"); // prime with canonical 8 bit part
break;
case 'r':
cmdopts.action = action_read;
cmdopts.filename = optarg;
break;
case 'w':
cmdopts.action = action_write;
cmdopts.filename = optarg;
break;
case 'i':
cmdopts.icsp = MP_ICSP_ENABLE | MP_ICSP_VCC;
break;
case 'I':
cmdopts.icsp = MP_ICSP_ENABLE;
break;
default:
print_help_and_exit(argv[0]);
break;
}
}
}
static int pca100_devices_init(void)
{
int i;
struct device_d *nand;
unsigned int mode[] = {
PD0_AIN_FEC_TXD0,
PD1_AIN_FEC_TXD1,
PD2_AIN_FEC_TXD2,
PD3_AIN_FEC_TXD3,
PD4_AOUT_FEC_RX_ER,
PD5_AOUT_FEC_RXD1,
PD6_AOUT_FEC_RXD2,
PD7_AOUT_FEC_RXD3,
PD8_AF_FEC_MDIO,
PD9_AIN_FEC_MDC | GPIO_PUEN,
PD10_AOUT_FEC_CRS,
PD11_AOUT_FEC_TX_CLK,
PD12_AOUT_FEC_RXD0,
PD13_AOUT_FEC_RX_DV,
PD14_AOUT_FEC_RX_CLK,
PD15_AOUT_FEC_COL,
PD16_AIN_FEC_TX_ER,
PF23_AIN_FEC_TX_EN,
PE12_PF_UART1_TXD,
PE13_PF_UART1_RXD,
PE14_PF_UART1_CTS,
PE15_PF_UART1_RTS,
PD25_PF_CSPI1_RDY,
PD26_PF_CSPI1_SS2,
PD27_PF_CSPI1_SS1,
PD28_PF_CSPI1_SS0,
PD29_PF_CSPI1_SCLK,
PD30_PF_CSPI1_MISO,
PD31_PF_CSPI1_MOSI,
/* USB host 2 */
PA0_PF_USBH2_CLK,
PA1_PF_USBH2_DIR,
PA2_PF_USBH2_DATA7,
PA3_PF_USBH2_NXT,
PA4_PF_USBH2_STP,
PD19_AF_USBH2_DATA4,
PD20_AF_USBH2_DATA3,
PD21_AF_USBH2_DATA6,
PD22_AF_USBH2_DATA0,
PD23_AF_USBH2_DATA2,
PD24_AF_USBH2_DATA1,
PD26_AF_USBH2_DATA5,
/* SDHC */
PB4_PF_SD2_D0,
PB5_PF_SD2_D1,
PB6_PF_SD2_D2,
PB7_PF_SD2_D3,
PB8_PF_SD2_CMD,
PB9_PF_SD2_CLK,
PC7_PF_USBOTG_DATA5,
PC8_PF_USBOTG_DATA6,
PC9_PF_USBOTG_DATA0,
PC10_PF_USBOTG_DATA2,
PC11_PF_USBOTG_DATA1,
PC12_PF_USBOTG_DATA4,
PC13_PF_USBOTG_DATA3,
PE0_PF_USBOTG_NXT,
PE1_PF_USBOTG_STP,
PE2_PF_USBOTG_DIR,
PE24_PF_USBOTG_CLK,
PE25_PF_USBOTG_DATA7,
/* display */
PA5_PF_LSCLK,
PA6_PF_LD0,
PA7_PF_LD1,
PA8_PF_LD2,
PA9_PF_LD3,
PA10_PF_LD4,
PA11_PF_LD5,
PA12_PF_LD6,
PA13_PF_LD7,
PA14_PF_LD8,
PA15_PF_LD9,
PA16_PF_LD10,
PA17_PF_LD11,
PA18_PF_LD12,
PA19_PF_LD13,
PA20_PF_LD14,
PA21_PF_LD15,
PA22_PF_LD16,
PA23_PF_LD17,
PA26_PF_PS,
PA28_PF_HSYNC,
PA29_PF_VSYNC,
PA31_PF_OE_ACD,
/* external I2C */
PD17_PF_I2C_DATA,
PD18_PF_I2C_CLK,
};
pca100_usb_init();
/* initizalize gpios */
for (i = 0; i < ARRAY_SIZE(mode); i++)
imx_gpio_mode(mode[i]);
imx27_add_nand(&nand_info);
imx27_add_fec(&fec_info);
imx27_add_mmc1(NULL);
imx27_add_fb(&pca100_fb_data);
#ifdef CONFIG_USB
pca100_usb_register();
#endif
nand = get_device_by_name("nand0");
devfs_add_partition("nand0", 0x00000, 0x40000, DEVFS_PARTITION_FIXED, "self_raw");
dev_add_bb_dev("self_raw", "self0");
devfs_add_partition("nand0", 0x40000, 0x20000, DEVFS_PARTITION_FIXED, "env_raw");
dev_add_bb_dev("env_raw", "env0");
armlinux_set_bootparams((void *)0xa0000100);
armlinux_set_architecture(2149);
return 0;
}
/*
* Initialize device structure. Returns success if
* initialization succeeded.
*/
static int gfar_probe(struct device_d *dev)
{
struct gfar_info_struct *gfar_info = dev->platform_data;
struct eth_device *edev;
struct gfar_private *priv;
struct device_d *mdev;
size_t size;
char devname[16];
char *p;
priv = xzalloc(sizeof(struct gfar_private));
edev = &priv->edev;
priv->mdiobus_tbi = gfar_info->mdiobus_tbi;
priv->regs = dev_get_mem_region(dev, 0);
if (IS_ERR(priv->regs))
return PTR_ERR(priv->regs);
priv->phyaddr = gfar_info->phyaddr;
priv->tbicr = gfar_info->tbicr;
priv->tbiana = gfar_info->tbiana;
mdev = get_device_by_name("gfar-mdio0");
if (mdev == NULL) {
pr_err("gfar-mdio0 was not found\n");
return -ENODEV;
}
priv->gfar_mdio = mdev->priv;
if (priv->mdiobus_tbi != 0) {
sprintf(devname, "%s%d", "gfar-tbiphy", priv->mdiobus_tbi);
mdev = get_device_by_name(devname);
if (mdev == NULL) {
pr_err("%s was not found\n", devname);
return -ENODEV;
}
}
priv->gfar_tbi = mdev->priv;
/*
* Allocate descriptors 64-bit aligned. Descriptors
* are 8 bytes in size.
*/
size = ((TX_BUF_CNT * sizeof(struct txbd8)) +
(RX_BUF_CNT * sizeof(struct rxbd8))) + BUF_ALIGN;
p = (char *)xmemalign(BUF_ALIGN, size);
priv->txbd = (struct txbd8 __iomem *)p;
priv->rxbd = (struct rxbd8 __iomem *)(p +
(TX_BUF_CNT * sizeof(struct txbd8)));
edev->priv = priv;
edev->init = gfar_init;
edev->open = gfar_open;
edev->halt = gfar_halt;
edev->send = gfar_send;
edev->recv = gfar_recv;
edev->get_ethaddr = gfar_get_ethaddr;
edev->set_ethaddr = gfar_set_ethaddr;
edev->parent = dev;
setbits_be32(priv->regs + GFAR_MACCFG1_OFFSET, GFAR_MACCFG1_SOFT_RESET);
udelay(2);
clrbits_be32(priv->regs + GFAR_MACCFG1_OFFSET, GFAR_MACCFG1_SOFT_RESET);
gfar_init_phy(edev);
return eth_register(edev);
}
int ifup(const char *name, unsigned flags)
{
int ret;
char *cmd, *cmd_discover;
const char *ip;
struct stat s;
int i;
struct device_d *dev;
struct eth_device *edev = eth_get_byname(name);
if (edev && edev->ipaddr && !(flags & IFUP_FLAG_FORCE))
return 0;
eth_set_current(edev);
env_push_context();
setenv("ip", "");
for (i = 0; i < ARRAY_SIZE(vars); i++)
setenv(vars[i], "");
cmd = basprintf("source /env/network/%s", name);
cmd_discover = basprintf("/env/network/%s-discover", name);
ret = run_command(cmd);
if (ret) {
pr_err("Running '%s' failed with %d\n", cmd, ret);
goto out;
}
ret = stat(cmd_discover, &s);
if (!ret) {
ret = run_command(cmd_discover);
if (ret) {
pr_err("Running '%s' failed with %d\n", cmd, ret);
goto out;
}
}
dev = get_device_by_name(name);
if (!dev) {
pr_err("Cannot find device %s\n", name);
goto out;
}
ret = eth_set_param(dev, "ethaddr");
if (ret)
goto out;
ip = getenv("ip");
if (!ip)
ip = "";
if (!strcmp(ip, "dhcp")) {
ret = run_command("dhcp");
if (ret)
goto out;
ret = eth_set_param(dev, "serverip");
if (ret)
goto out;
} else if (!strcmp(ip, "static")) {
for (i = 0; i < ARRAY_SIZE(vars); i++) {
ret = eth_set_param(dev, vars[i]);
if (ret)
goto out;
}
} else {
pr_err("unknown ip type: %s\n", ip);
ret = -EINVAL;
goto out;
}
ret = 0;
out:
env_pop_context();
free(cmd);
free(cmd_discover);
return ret;
}
static int pca100_devices_init(void)
{
int i;
struct device_d *nand;
unsigned int mode[] = {
PD0_AIN_FEC_TXD0,
PD1_AIN_FEC_TXD1,
PD2_AIN_FEC_TXD2,
PD3_AIN_FEC_TXD3,
PD4_AOUT_FEC_RX_ER,
PD5_AOUT_FEC_RXD1,
PD6_AOUT_FEC_RXD2,
PD7_AOUT_FEC_RXD3,
PD8_AF_FEC_MDIO,
PD9_AIN_FEC_MDC | GPIO_PUEN,
PD10_AOUT_FEC_CRS,
PD11_AOUT_FEC_TX_CLK,
PD12_AOUT_FEC_RXD0,
PD13_AOUT_FEC_RX_DV,
PD14_AOUT_FEC_CLR,
PD15_AOUT_FEC_COL,
PD16_AIN_FEC_TX_ER,
PF23_AIN_FEC_TX_EN,
PE12_PF_UART1_TXD,
PE13_PF_UART1_RXD,
PE14_PF_UART1_CTS,
PE15_PF_UART1_RTS,
PD25_PF_CSPI1_RDY,
PD26_PF_CSPI1_SS2,
PD27_PF_CSPI1_SS1,
PD28_PF_CSPI1_SS0,
PD29_PF_CSPI1_SCLK,
PD30_PF_CSPI1_MISO,
PD31_PF_CSPI1_MOSI,
/* USB host 2 */
PA0_PF_USBH2_CLK,
PA1_PF_USBH2_DIR,
PA2_PF_USBH2_DATA7,
PA3_PF_USBH2_NXT,
PA4_PF_USBH2_STP,
PD19_AF_USBH2_DATA4,
PD20_AF_USBH2_DATA3,
PD21_AF_USBH2_DATA6,
PD22_AF_USBH2_DATA0,
PD23_AF_USBH2_DATA2,
PD24_AF_USBH2_DATA1,
PD26_AF_USBH2_DATA5,
};
/* disable the usb phys */
imx_gpio_mode((GPIO_PORTB | 23) | GPIO_GPIO | GPIO_IN);
gpio_direction_output(GPIO_PORTB + 23, 1);
imx_gpio_mode((GPIO_PORTB | 24) | GPIO_GPIO | GPIO_IN);
gpio_direction_output(GPIO_PORTB + 24, 1);
/* initizalize gpios */
for (i = 0; i < ARRAY_SIZE(mode); i++)
imx_gpio_mode(mode[i]);
register_device(&nand_dev);
register_device(&sdram_dev);
register_device(&fec_dev);
PCCR1 |= PCCR1_PERCLK2_EN;
#ifdef CONFIG_USB
pca100_usbh_init();
register_device(&usbh2_dev);
#endif
nand = get_device_by_name("nand0");
devfs_add_partition("nand0", 0x00000, 0x40000, PARTITION_FIXED, "self_raw");
dev_add_bb_dev("self_raw", "self0");
devfs_add_partition("nand0", 0x40000, 0x20000, PARTITION_FIXED, "env_raw");
dev_add_bb_dev("env_raw", "env0");
armlinux_add_dram(&sdram_dev);
armlinux_set_bootparams((void *)0xa0000100);
armlinux_set_architecture(2149);
return 0;
}
