static __init void m1_init_machine(void) { meson_cache_init(); #ifdef CONFIG_AML_SUSPEND pm_power_suspend = meson_power_suspend; #endif /*CONFIG_AML_SUSPEND*/ power_hold(); // pm_power_off = power_off; //Elvis fool device_clk_setting(); device_pinmux_init(); // LED_PWM_REG0_init(); platform_add_devices(platform_devs, ARRAY_SIZE(platform_devs)); #ifdef CONFIG_USB_DWC_OTG_HCD printk("***m1_init_machine: usb set mode.\n"); set_usb_phy_clk(USB_PHY_CLOCK_SEL_XTAL_DIV2); // set_usb_phy_id_mode(USB_PHY_PORT_A, USB_PHY_MODE_SW_HOST); lm_device_register(&usb_ld_a); set_usb_phy_id_mode(USB_PHY_PORT_B,USB_PHY_MODE_SW_HOST); lm_device_register(&usb_ld_b); #endif disable_unused_model(); }
int __init usb_devices_init(void) { struct lm_device *lmdev; int rc = -1; /* Power Up the 48MHz PLL */ /* REG_CLKPWR_USBPLL_ENABLE |= 1; */ /* Turn on the output gate of the 48MHz PLL */ /* REG_CLKPWR_USBPLL_OEN |= 1; */ /* Turn on the HS USB in the usb control register */ /* REG_USB_CONTROL_REG |= REG_USB_CONTROL_USB_ON; */ lmdev = kmalloc(sizeof(struct lm_device), GFP_KERNEL); if (lmdev) { memset(lmdev, 0, sizeof(struct lm_device)); lmdev->resource.start = HW_USBOTG_BASE; lmdev->resource.end = lmdev->resource.start + SZ_256K - 1; lmdev->resource.flags = IORESOURCE_MEM; lmdev->irq = IRQ_USBHSOTG; lmdev->id = -2; rc = lm_device_register(lmdev); } return rc; }
static void __init ap_init(void) { unsigned long sc_dec; int i; platform_device_register(&cfi_flash_device); sc_dec = readl(VA_SC_BASE + INTEGRATOR_SC_DEC_OFFSET); for (i = 0; i < 4; i++) { struct lm_device *lmdev; if ((sc_dec & (16 << i)) == 0) continue; lmdev = kzalloc(sizeof(struct lm_device), GFP_KERNEL); if (!lmdev) continue; lmdev->resource.start = 0xc0000000 + 0x10000000 * i; lmdev->resource.end = lmdev->resource.start + 0x0fffffff; lmdev->resource.flags = IORESOURCE_MEM; lmdev->irq = IRQ_AP_EXPINT0 + i; lmdev->id = i; lm_device_register(lmdev); } }
static int __init dwc_hsic_init(void) { dwc_wifi_unreset(); dwc_hsic_unreset(); return lm_device_register(&dwc_usb_hsic); }
static void __init ap_init_of(void) { unsigned long sc_dec; int i; of_platform_populate(NULL, of_default_bus_match_table, ap_auxdata_lookup, NULL); sc_dec = readl(VA_SC_BASE + INTEGRATOR_SC_DEC_OFFSET); for (i = 0; i < 4; i++) { struct lm_device *lmdev; if ((sc_dec & (16 << i)) == 0) continue; lmdev = kzalloc(sizeof(struct lm_device), GFP_KERNEL); if (!lmdev) continue; lmdev->resource.start = 0xc0000000 + 0x10000000 * i; lmdev->resource.end = lmdev->resource.start + 0x0fffffff; lmdev->resource.flags = IORESOURCE_MEM; lmdev->irq = IRQ_AP_EXPINT0 + i; lmdev->id = i; lm_device_register(lmdev); } }
static __init void m1_init_machine(void) { meson_cache_init(); device_clk_setting(); device_pinmux_init(); platform_add_devices(platform_devs, ARRAY_SIZE(platform_devs)); #ifdef CONFIG_USB_DWC_OTG_HCD set_usb_phy_clk(USB_PHY_CLOCK_SEL_XTAL_DIV2); lm_device_register(&usb_ld_a); lm_device_register(&usb_ld_b); #endif #ifdef CONFIG_SATA_DWC_AHCI set_sata_phy_clk(SATA_PHY_CLOCK_SEL_DEMOD_PLL); lm_device_register(&sata_ld); #endif }
static int dwc_otg_platform_driver_probe( struct platform_device *_dev ) { int irq; irq = _dev->resource[1].start; lm_device.irq = irq; lm_device.resource = _dev->resource[0]; lm_device.id = _dev->id; return lm_device_register(&lm_device); }
static void __init init_machine(void) { edb_trace(1); #warning "add some sys ctrl register operation here, such as enable something .etc" cache_init(); #warning "don't replace arm_pm_restart funciton if pm.c is built into boot image " arm_pm_restart = board_arch_reset; lm_device_register(&usb_sft_otg); return; }
int __init usb_devices_init( void ) { struct lm_device *lmdev; uint32_t pll_ctl; int rc = -1; pll_ctl = readl( IO_ADDRESS( CMU_R_PLA_PLL_CTL0_MEMADDR ) ); // @KP: 090316: setup for usb device mode // bypass PMU for usb device testing; reg 0xb00a8 // writel(0x6a3, IO_ADDRESS(CMU_R_MODE_CTL_MEMADDR)); // config usb broadcom phy (8-bit) for otg mode (default to device mode); reset and unreset pair; reg 0xb0244 writel(0x004069d5, IO_ADDRESS(CMU_R_USB_PHY0_MEMADDR)); writel(0x0041a9d5, IO_ADDRESS(CMU_R_USB_PHY0_MEMADDR)); // enable differential pll for usb; reg 0xb0040 bit 9 pll_ctl |= CMU_F_PLA_EN_CMLBUF6_MASK; writel(pll_ctl, IO_ADDRESS(CMU_R_PLA_PLL_CTL0_MEMADDR)); lmdev = kmalloc(sizeof(struct lm_device), GFP_KERNEL); if (lmdev) { memset( lmdev, 0 , sizeof(struct lm_device)); lmdev->resource.start = USB_REG_BASE_ADDR; lmdev->resource.end = lmdev->resource.start + SZ_4K -1; lmdev->resource.flags = IORESOURCE_MEM ; lmdev->irq = BCM4760_INTR_USB; lmdev->id = -2; rc = lm_device_register(lmdev); if (rc) { printk(KERN_ERR "can't register BCM4760 OTG core device\n"); } } return rc; }
static void __init ap_init_of(void) { unsigned long sc_dec; struct device_node *root; struct device_node *syscon; struct device *parent; struct soc_device *soc_dev; struct soc_device_attribute *soc_dev_attr; u32 ap_sc_id; int err; int i; /* Here we create an SoC device for the root node */ root = of_find_node_by_path("/"); if (!root) return; syscon = of_find_node_by_path("/syscon"); if (!syscon) return; ap_syscon_base = of_iomap(syscon, 0); if (!ap_syscon_base) return; ap_sc_id = readl(ap_syscon_base); soc_dev_attr = kzalloc(sizeof(*soc_dev_attr), GFP_KERNEL); if (!soc_dev_attr) return; err = of_property_read_string(root, "compatible", &soc_dev_attr->soc_id); if (err) return; err = of_property_read_string(root, "model", &soc_dev_attr->machine); if (err) return; soc_dev_attr->family = "Integrator"; soc_dev_attr->revision = kasprintf(GFP_KERNEL, "%c", 'A' + (ap_sc_id & 0x0f)); soc_dev = soc_device_register(soc_dev_attr); if (IS_ERR(soc_dev)) { kfree(soc_dev_attr->revision); kfree(soc_dev_attr); return; } parent = soc_device_to_device(soc_dev); integrator_init_sysfs(parent, ap_sc_id); of_platform_populate(root, of_default_bus_match_table, ap_auxdata_lookup, parent); sc_dec = readl(ap_syscon_base + INTEGRATOR_SC_DEC_OFFSET); for (i = 0; i < 4; i++) { struct lm_device *lmdev; if ((sc_dec & (16 << i)) == 0) continue; lmdev = kzalloc(sizeof(struct lm_device), GFP_KERNEL); if (!lmdev) continue; lmdev->resource.start = 0xc0000000 + 0x10000000 * i; lmdev->resource.end = lmdev->resource.start + 0x0fffffff; lmdev->resource.flags = IORESOURCE_MEM; lmdev->irq = IRQ_AP_EXPINT0 + i; lmdev->id = i; lm_device_register(lmdev); } }
static void __init cns3xxx_init(void) { int i; #ifdef CONFIG_CACHE_L2X0 /* 1MB (128KB/way), 8-way associativity, evmon/parity/share enabled * Bits: .... ...0 0111 1001 0000 .... .... .... */ cns3xxx_l2x0_init(); #endif #ifdef CONFIG_CACHE_L2CC l2cc_init((void __iomem *) CNS3XXX_L2C_BASE_VIRT); #endif #ifdef CONFIG_CNS3XXX_DMAC dmac_init(); #endif #ifdef CONFIG_CNS3XXX_RAID cns_rdma_init(); #endif show_board_version(); { volatile unsigned long *pciecfg0; pciecfg0 = (volatile unsigned long *)CNS3XXX_PCIE0_CFG0_BASE_VIRT; pciecfg0[1] |= 7; printk("usec at kernel start: 0x%08lX\n", *(volatile unsigned long *)(CNS3XXX_PCIE0_MEM_BASE_VIRT+0x14)); } ts43xx_ahci_init(); for (i = 0; i < ARRAY_SIZE(amba_devs); i++) { struct amba_device *d = amba_devs[i]; int ret; cns3xxx_pwr_power_up(CNS3XXX_PWR_PLL(PLL_LCD)); cns3xxx_pwr_clk_en(CNS3XXX_PWR_CLK_EN(LCDC)); cns3xxx_pwr_soft_rst(CNS3XXX_PWR_SOFTWARE_RST(LCDC)); ret = amba_device_register(d, &iomem_resource); if(ret) printk("%s=>%d: %d\n", __FUNCTION__, __LINE__, ret); } platform_add_devices(cns3xxx_devs, ARRAY_SIZE(cns3xxx_devs)); lm_device_register(&cns3xxx_usb_otg_device); i2c_register_board_info(0, cns3xxx_i2c_devices, ARRAY_SIZE(cns3xxx_i2c_devices)); i2c_register_board_info(1, cns3xxx_i2c_gpio_devices, ARRAY_SIZE(cns3xxx_i2c_gpio_devices)); spi_register_board_info(cns3xxx_spi_devices, ARRAY_SIZE(cns3xxx_spi_devices)); cns3xxx_proc_dir = proc_mkdir("cns3xxx", NULL); #ifdef CONFIG_DEBUG_FS cns3xxx_debugfs_dir = debugfs_create_dir("cns3xxx", NULL); #endif #ifdef CONFIG_CACHE_L2CC l2cc_proc_init(); #endif pm_power_off = cns3xxx_power_off; }
/** * of_lm_device_create - Alloc, initialize and register an of_device * @np: pointer to node to create device for * @bus_id: name to assign device * @parent: Linux device model parent device. * * Returns pointer to created lm device, or NULL if a device was not * registered. Unavailable devices will not get registered. */ static struct lm_device *of_lm_device_create(struct device_node *node, const char *bus_id, void *platform_data, struct device *parent) { struct lm_device *dev; const void *prop; // struct resource *res, temp_res; //int ret,id,irq; int ret,id; pr_debug("Creating of lm device %s\n", node->full_name); if (!of_device_is_available(node)) return NULL; /* Allow the HW Peripheral ID to be overridden */ prop = of_get_property(node, "lm-periph-id", NULL); if (prop) id = of_read_ulong(prop, 1); else id = -1; // root dev dev = kzalloc(sizeof(struct lm_device),GFP_KERNEL); if (!dev){ printk(KERN_ERR "out of memory to alloc lm device\n"); return NULL; } /* prop = of_get_property(node, "irq", NULL); if (prop) irq = of_read_ulong(prop, 1); else{ irq = 0; } printk(KERN_ERR " --- irq: %d\n",irq); */ /* setup generic device info */ dev->id = id; // dev->irq = irq; dev->dev.coherent_dma_mask = ~0; dev->dev.of_node = of_node_get(node); dev->dev.parent = parent; dev->dev.platform_data = platform_data; dev->dev.coherent_dma_mask = DMA_BIT_MASK(32); if(id >= 0) dev_set_name(&dev->dev,"lm%d", dev->id); else dev_set_name(&dev->dev,"lm-root"); /* setup lm-specific device info */ dev->dma_mask_room = DMA_BIT_MASK(32); // ret = of_address_to_resource(node, 0, &dev->resource); // if (ret) // goto err_free; ret = lm_device_register(dev); if (ret) goto err_free; return dev; err_free: put_device(&dev->dev); return NULL; }