void *kzalloc(size_t size, gfp_t flags)
{
    dde_printf("kzalloc begin\n");
    void *ret = dde_kmalloc(size, flags);
    dde_printf("kzalloc end\n");
    return ret;
}

DDE_WEAK ktime_t ktime_get() {
	dde_printf("ktime_get not implemented\n");
	return (ktime_t) { .tv64 = 0 };
}

/* This requires 'wrkmem' of size LZO1X_1_MEM_COMPRESS */
DDE_WEAK int lzo1x_1_compress(const unsigned char * a, size_t b, unsigned char * c, size_t * d, void * e) {
	dde_printf("lzo1x_1_compress not implemented\n");
	return 0;
}

DDE_WEAK bool bcm_dma_is_busy(void __iomem *dma_chan_base) {
	dsb();

	return readl(dma_chan_base + BCM2708_DMA_CS) & BCM2708_DMA_ACTIVE;

	dde_printf("bcm_dma_is_busy not implemented\n");
	return 0;
}

DDE_WEAK void bcm_dma_wait_idle(void __iomem * dma_chan_base) {
    dsb();

  /* ugly busy wait only option for now */
    while (readl(dma_chan_base + BCM2708_DMA_CS) & BCM2708_DMA_ACTIVE)
        cpu_relax();

    return;

	dde_printf("bcm_dma_wait_idle not implemented\n");
}

DDE_WEAK void bcm_dma_start(void __iomem *dma_chan_base, 
        dma_addr_t control_block)
{
	dsb();	/* ARM data synchronization (push) operation */

	writel(control_block,	     dma_chan_base + BCM2708_DMA_ADDR);
	writel(BCM2708_DMA_ACTIVE,   dma_chan_base + BCM2708_DMA_CS);

    return;

	dde_printf("bcm_dma_start not implemented\n");
}

void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,
		    gfp_t gfp, struct dma_attrs *attrs)
{
    kprintf("%s begin\n", __func__);
    printk("dma_alloc_writecombine size %08x\n", size);
	void *cpuaddr =
	    dde_kva_alloc_pages((size + PAGE_SIZE - 1) / PAGE_SIZE,
				  UCORE_KAP_IO);
	*handle = (dma_addr_t)__pfn_to_bus(cpuaddr);
	return cpuaddr;

	dde_printf("arm_dma_alloc not implemented\n");
}

DDE_WEAK int bcm_dma_chan_alloc(unsigned int a, void __iomem **out_dma_base, 
                                int * out_dma_irq) 
{
    int rc = 0;
    resource_size_t DMA_SIZE = SZ_4K;
    void __iomem *dma_base = __arm_ioremap(DMA_BASE, DMA_SIZE, 0);
    *out_dma_base = BCM2708_DMA_CHANIO(dma_base, rc);
    *out_dma_irq = bcm_dma_irqs[rc];
    return rc;

	dde_printf("bcm_dma_chan_alloc not implemented\n");
	return 0;
}

DDE_WEAK int printk(const char * a, ...) {
	dde_printf("printk not implemented\n");
	return 0;
}

DDE_WEAK void cdev_del(struct cdev * a) {
	dde_printf("cdev_del not implemented\n");
}

DDE_WEAK int alloc_chrdev_region(dev_t * a, unsigned int b, unsigned int c, const char * d) {
	dde_printf("alloc_chrdev_region not implemented\n");
	return 0;
}

DDE_WEAK void module_put(struct module * a) {
	dde_printf("module_put not implemented\n");
}

DDE_WEAK void hrtimer_start_range_ns(struct hrtimer * a, ktime_t b, unsigned long c, const enum hrtimer_mode d) {
	dde_printf("hrtimer_start_range_ns not implemented\n");
}

DDE_WEAK u64 hrtimer_forward(struct hrtimer * a, ktime_t b, ktime_t c) {
	dde_printf("hrtimer_forward not implemented\n");
	return 0;
}

DDE_WEAK void complete(struct completion * a) {
	dde_printf("complete not implemented\n");
}

DDE_WEAK int strncmp(const char * a, const char * b, __kernel_size_t c) {
	dde_printf("strncmp not implemented\n");
	return 0;
}

DDE_WEAK int devm_request_threaded_irq(struct device * a, unsigned int b, irq_handler_t c, irq_handler_t d, unsigned long e, const char * f, void * g) {
	dde_printf("devm_request_threaded_irq not implemented\n");
	return 0;
}

DDE_WEAK int hrtimer_cancel(struct hrtimer * a) {
	dde_printf("hrtimer_cancel not implemented\n");
	return 0;
}

DDE_WEAK void trace_hardirqs_on() {
	dde_printf("trace_hardirqs_on not implemented\n");
}

DDE_WEAK void hrtimer_init(struct hrtimer * a, clockid_t b, enum hrtimer_mode c) {
	dde_printf("hrtimer_init not implemented\n");
}

/* This is the Right Way to get a module: if it fails, it's being removed,
 * so pretend it's not there. */
DDE_WEAK bool try_module_get(struct module * a) {
	dde_printf("try_module_get not implemented\n");
	return 0;
}