int bpamemio_allocmem(BPAMemAllocMemData *in_data) { BPAMemAllocMemData data; unsigned int dev; // reserve a device dev = find_next_device(); if(dev == -1) // nothing left { DEBUG_PRINTK("memory already allocated\n"); return -1; } if(copy_from_user(&data, in_data, sizeof(BPAMemAllocMemData))) { bpamem_dev[dev].used = 0; return -1; } DEBUG_PRINTK("data.bpa_part = %s\n", data.bpa_part); data.device_num = dev; if(data.mem_size % PAGE_SIZE != 0) data.mem_size = (data.mem_size / PAGE_SIZE + 1) * PAGE_SIZE; bpamem_dev[dev].part = bpa2_find_part(data.bpa_part); if(!bpamem_dev[dev].part) { DEBUG_PRINTK("bpa part %s not found\n", data.bpa_part); bpamem_dev[dev].used = 0; return -1; } bpamem_dev[dev].phys_addr = bpa2_alloc_pages(bpamem_dev[dev].part, data.mem_size / PAGE_SIZE, 1, GFP_KERNEL); if(!bpamem_dev[dev].phys_addr) { DEBUG_PRINTK("could not alloc bpa mem\n"); bpamem_dev[dev].used = 0; return -ENOMEM; } bpamem_dev[dev].size = data.mem_size; if(copy_to_user(in_data, &data, sizeof(BPAMemAllocMemData))) { bpa2_free_pages(bpamem_dev[dev].part, bpamem_dev[dev].phys_addr); bpamem_dev[dev].phys_addr = 0; bpamem_dev[dev].used = 0; return -1; } return 0; }
int bpamemio_mapmem(BPAMemMapMemData *in_data) { BPAMemMapMemData data; unsigned int dev; // reserve a device dev = find_next_device(); if(dev == -1) // nothing left { DEBUG_PRINTK("memory already allocated\n"); return -1; } if(copy_from_user(&data, in_data, sizeof(BPAMemMapMemData))) { bpamem_dev[dev].used = 0; return -1; } DEBUG_PRINTK("data.bpa_part = %s\n", data.bpa_part); data.device_num = dev; bpamem_dev[dev].part = bpa2_find_part(data.bpa_part); if(!bpamem_dev[dev].part) { DEBUG_PRINTK("bpa part %s not found\n", data.bpa_part); bpamem_dev[dev].used = 0; return -1; } bpamem_dev[dev].size = data.mem_size; bpamem_dev[dev].phys_addr = data.phys_addr; if(copy_to_user(in_data, &data, sizeof(BPAMemMapMemData))) { bpa2_free_pages(bpamem_dev[dev].part, bpamem_dev[dev].phys_addr); bpamem_dev[dev].phys_addr = 0; bpamem_dev[dev].used = 0; return -1; } return 0; }
/* * stmfb_createfb * Create framebuffer related state and register with upper layers */ static int stmfb_createfb(struct stmfb_info *i, int display, const char *name) { int ret; unsigned long nPages; int fb_registered = 0; const struct stmcore_display_pipeline_data * const pd = *((struct stmcore_display_pipeline_data **) i->platformDevice->dev.platform_data); DPRINTK("\n"); /* * Copy all available display modes into the modelist, before we parse * the module parameters to get the default mode. */ stmfb_enumerate_modes(i); /* * Need to set the framebuffer operation table and get hold of the display * plane before parsing the module parameters so fb_find_mode can work. */ i->info.fbops = &stmfb_ops; if((ret = stmfb_parse_module_parameters(i, display)) < 0) goto failed0; /* can create blitter only after module parameters have been parsed */ if((ret = stmfb_probe_get_blitter(i,pd))<0) goto failed0; nPages = (i->ulFBSize + PAGE_SIZE - 1) / PAGE_SIZE; i->FBPart = bpa2_find_part ("bigphysarea"); i->ulPFBBase = i->FBPart ? bpa2_alloc_pages (i->FBPart, nPages, 0, GFP_KERNEL) : 0; if (!i->ulPFBBase) { printk(KERN_WARNING "Failed to allocate fb%d memory, requested size = %lu\n",display, i->ulFBSize); ret = -ENOMEM; goto failed0; } /* try to allocate memory from BPA2 as additional memory for graphics operations. Basically, this is not vital, but driver loading will still fail if an auxsize has been specified in the module parameters which can not be satisfied, either because no BPA2 partition 'gfx-memory' exists, or if it's not large enough for the given auxsize. */ /* Please note that due to hardware limitations, this can actually be a bit complex (2 & 3): 1) we look for partitions labelled 'gfx-memory-[0...x]', each of which should be 64MB in size and be aligned to a 64MB bank. This makes the process quite easy for us. 2) Failing that, we try to use a partition labelled 'gfx-memory'. Now we have to make sure ourselves that each allocation does not cross a 64MB bank boundary. 3) Failing that, too, or in case the 'gfx-memory' partition not being large enough to accomodate for the amount of gfx memory requested in the module options, we will do the same but this time use the 'bigphysarea' partition. */ /* So, either one can configure several 'gfx-memory-%d' partitions (preferred, to have maximum control over placement of gfx memory), just use one large 'gfx-memory' partition, or configure nothing at all and be limited to 'bigphysarea' memory. The combined memory of all the allocations will be made available to DirectFB. */ /* FIXME: this code is way too complex! */ #define MEMORY64MB_SIZE (1<<26) if (i->AuxSize[0]) { /* aux memory was requested */ unsigned int idx; /* index into i->AuxPart[] */ /* order of partnames is important here! */ static const char *partnames[] = { "gfx-memory-%d", "gfx-memory", "bigphysarea" }; unsigned int partnameidx /* index into partnames[] */, partidx /* index in case of 'gfx-memory-%d' */; char partname[14]; /* real name in case of 'gfx-memory-%d' */ struct bpa2_part *part; unsigned long still_needed = i->AuxSize[0]; unsigned long this_alloc; int alignment; partidx = 0; /* find a partition suitable for us, in the preferred order, as outlined above */ for (partnameidx = 0; partnameidx < ARRAY_SIZE (partnames); ++partnameidx) { sprintf (partname, partnames[partnameidx], 0); part = bpa2_find_part (partname); if (part) break; } if (!part) { printk (KERN_ERR "no BPA2 partitions found for auxmem!\n"); goto failed_bigphys; } idx = 0; restart: if (still_needed >= MEMORY64MB_SIZE) { /* we first try to satisfy from a 64MB aligned region */ this_alloc = MEMORY64MB_SIZE; /* don't request a specific alignment if individual 'gfx-memory-%d' partitions are configured in the kernel */ alignment = (partnameidx == 0) ? 0 : MEMORY64MB_SIZE / PAGE_SIZE; } else { /* if requested size is < 64MB, we are optimistic and hope it will fit into one 64MB bank without alignment restrictions. This doesn't mean we will be happy with a region crossing that boundary, i.e. we will still make sure all restrictions are met. We are really being just optimistic here. */ this_alloc = still_needed; alignment = 0; } while (part && idx < ARRAY_SIZE (i->AuxPart) && still_needed) { int this_pages; unsigned long base; printk (KERN_INFO "trying to alloc %lu bytes (align: %.4x, still needed:" " %lu) from '%s' for GFX%d auxmem\n", this_alloc, alignment, still_needed, partname, display); this_pages = (this_alloc + PAGE_SIZE - 1) / PAGE_SIZE; base = bpa2_alloc_pages (part, this_pages, alignment, GFP_KERNEL); if (base) { /* make sure it doesn't cross a 64MB boundary. At some point we will be using the new BPA2 allocator API... */ if ((base & ~(MEMORY64MB_SIZE - 1)) != ((base + this_alloc - 1) & ~(MEMORY64MB_SIZE - 1))) { unsigned long topAddress; printk ("%s: %8.lx + %lu (%d pages) crosses a 64MB boundary, retrying!\n", __FUNCTION__, base, this_alloc, this_pages); /* free and try a new reservation with different attributes, hoping nobody requests bpa2 memory in between... */ bpa2_free_pages (part, base); if (partnameidx == 0) { /* if we have 'gfx-memory-%d' partitions, try the next one */ /* Getting here doesn't neccessarily mean there is an error in the BPA2 partition definition. This can happen if e.g. two framebuffers are configured and the auxmem size requested is larger but not a multiple of 64MB (since we are optimistic and try to re-use partially used partitions), so don't be tempted to put a WARN_ON() here! */ sprintf (partname, partnames[partnameidx], ++partidx); part = bpa2_find_part (partname); continue; } if (still_needed == this_alloc && alignment == 0) { /* this can only happen on the last chunk of memory needed. So we first try to fit it into its own region. I.e. we first try to put the last chunk into a partly used bank. If we succeed, but the chunk now spans a boundary (which gets us here), we try to put it into its own bank. If that fails, too, we will come back again (this time with alignment == 1) and split the chunk into two. */ alignment = MEMORY64MB_SIZE / PAGE_SIZE; continue; } /* standard case, allocate up to the end of current 64MB bank, effectively splitting the current chunk into two. */ #define _ALIGN_UP(addr,size) (((addr)+((size)-1))&(~((size)-1))) topAddress = _ALIGN_UP (base, MEMORY64MB_SIZE); this_alloc = topAddress - base; this_pages = (this_alloc + PAGE_SIZE - 1) / PAGE_SIZE; /* alignment should be 0 or 1 here */ WARN_ON (alignment != 0 && alignment != 1); base = bpa2_alloc_pages (part, this_pages, alignment, GFP_KERNEL); if (!base) { /* shouldn't happen here, since we just moments ago suceeded in allocating even more memory than now, so we don't know what to do and kindof panic ...*/ break; } } /* we now have found a more or less nice place to chill. */ i->AuxPart[idx] = part; i->AuxBase[idx] = base; i->AuxSize[idx] = this_alloc; ++idx; still_needed -= this_alloc; printk (KERN_INFO "success: base: %.8lx, still needed: %lu\n", base, still_needed); if (still_needed >= MEMORY64MB_SIZE) { /* we first try to satisfy from a 64MB aligned region */ this_alloc = MEMORY64MB_SIZE; alignment = (partnameidx == 0) ? 0 : MEMORY64MB_SIZE / PAGE_SIZE; } else { /* if requested size is < 64MB we are on the last chunk of memory blocks. We are otimistic and hope it will fit into a possibly already partly used 64MB bank without alignment restrictions, i.e. we hope it will not span a 64MB boundary. If that's not the case, we will again use an alignment of 64MB, so as to reduce scattering of the auxmem chunks. */ this_alloc = still_needed; alignment = 0; /* if using 'gfx-memory-%d' partitions, try to share the last chunk with another chunk (in a possibly partly used partition). */ if (partnameidx == 0) partidx = -1; } if (partnameidx == 0) { /* in case we are using 'gfx-memory-%d' as partition name, make sure we advance to the next partition */ sprintf (partname, partnames[partnameidx], ++partidx); part = bpa2_find_part (partname); } } else { if (alignment > 1) { if (still_needed == this_alloc) /* make sure not to get into an endless loop which would be switching around the alignment all the time. */ alignment = 1; else /* try again with different alignment rules */ alignment = 0; } else { /* failed: couldn't allocate any memory at all, even without any alignment restrictions. 1) In case there are 'gfx-memory-%d' partitions, we advance to the next one. 2) In case we had been using 'gfx-memory' as partition name, we now try 'bigphysarea'*/ if (partnameidx == 0) { /* use next 'gfx-memory-%d' partition */ BUG_ON (strcmp (partnames[partnameidx], "gfx-memory-%d")); sprintf (partname, partnames[partnameidx], ++partidx); part = bpa2_find_part (partname); } else if (partnameidx == 1) { /* advance from 'gfx-memory' to 'bigphysarea' partition name */ BUG_ON (strcmp (partnames[partnameidx], "gfx-memory")); sprintf (partname, partnames[++partnameidx], 0); BUG_ON (strcmp (partnames[partnameidx], "bigphysarea")); part = bpa2_find_part (partname); goto restart; } else /* that's it, there are no partitions left to check for auxmem */ break; } } } if (still_needed) { /* not enough chill space configured for BPA2 */ printk (KERN_WARNING "Failed to allocate enough fb%d auxmem " "(still need %lu bytes)\n", display, still_needed); ret = -ENOMEM; goto failed_auxmem; } } if(stm_display_plane_connect_to_output(i->pFBPlane, i->pFBMainOutput) < 0) { printk(KERN_ERR "fb%d display cannot be connected to display output pipeline, this is very bad!\n",display); ret = -EIO; goto failed_auxmem; } if(stm_display_plane_lock(i->pFBPlane) < 0) { printk(KERN_WARNING "fb%d display plane may already be in use by another driver\n",display); ret = -EBUSY; goto failed_auxmem; } i->main_config.activate = STMFBIO_ACTIVATE_IMMEDIATE; if(stmfb_set_output_configuration(&i->main_config,i)<0) { printk(KERN_WARNING "fb%d main output configuration is unsupported\n",display); ret = -EINVAL; goto failed_auxmem; } /* * Get the framebuffer layer default extended var state and capabilities */ i->current_var_ex.layerid = 0; if((ret = stmfb_encode_var_ex(&i->current_var_ex, i)) < 0) { printk(KERN_WARNING "fb%d failed to get display plane's extended capabilities\n",display); goto failed_auxmem; } /* Setup the framebuffer info for registration */ i->info.screen_base = ioremap_nocache(i->ulPFBBase,i->ulFBSize); i->info.flags = FBINFO_DEFAULT | FBINFO_PARTIAL_PAN_OK | FBINFO_HWACCEL_YPAN; strcpy(i->info.fix.id, name); /* identification string */ i->info.fix.smem_start = i->ulPFBBase; /* Start of frame buffer mem (physical address) */ i->info.fix.smem_len = i->ulFBSize; /* Length of frame buffer mem as the device sees it */ i->info.fix.mmio_start = pd->mmio; /* memory mapped register access */ i->info.fix.mmio_len = pd->mmio_len; /* Length of Memory Mapped I/O */ i->info.fix.type = FB_TYPE_PACKED_PIXELS; /* see FB_TYPE_* */ i->info.fix.type_aux = 0; /* Interleave for interleaved Planes */ i->info.fix.xpanstep = 0; /* zero if no hardware panning */ i->info.fix.ypanstep = 1; /* zero if no hardware panning */ i->info.fix.ywrapstep = 0; /* zero if no hardware ywrap */ i->info.pseudo_palette = &i->pseudo_palette; if(fb_alloc_cmap(&i->info.cmap, 256, 1)<0) { printk(KERN_ERR "fb%d unable to allocate colour map\n",display); ret = -ENOMEM; goto failed_ioremap; } if(i->info.cmap.len != 256) { printk(KERN_ERR "fb%d WTF colour map length is wrong????\n",display); } if (register_framebuffer(&i->info) < 0) { printk(KERN_ERR "fb%d register =_framebuffer failed!\n",display); ret = -ENODEV; goto failed_cmap; } /* * If there was no console activated on the registered framebuffer, we have * to force the display mode be updated. This sequence is cribbed from the * matroxfb driver. */ if(!i->current_videomode_valid) { i->info.var.activate |= FB_ACTIVATE_FORCE; if((ret = fb_set_var(&i->info, &i->info.var))<0) { printk(KERN_WARNING "fb%d failed to set default display mode, display pipeline may already be in use\n",display); goto failed_register; } } //#if (defined(UFS912) || defined(HS7110) || defined(HS7119) || defined(HS7420) || defined(HS7429) || defined(HS7810A) || defined(HS7819) || defined(ATEMIO520) || defined(ATEMIO530) || defined(SPARK) || defined(AT7500)) && defined(__TDT__) // WORKAROUND: Clear the framebuffer memset(i->info.screen_base, 0x00, i->ulFBSize); //#endif stmfb_init_class_device(i); DPRINTK("out\n"); return 0; failed_register: fb_registered = 1; unregister_framebuffer (&i->info); failed_cmap: fb_dealloc_cmap (&i->info.cmap); failed_ioremap: iounmap (i->info.screen_base); i->info.screen_base = NULL; failed_auxmem: stmfb_destroy_auxmem (i); failed_bigphys: bpa2_free_pages (i->FBPart, i->ulPFBBase); i->ulPFBBase = 0; i->FBPart = NULL; failed0: if (!fb_registered) /* unregister_framebuffer() does fb_destroy_modelist() for us, so don't destroy it twice! */ fb_destroy_modelist (&i->info.modelist); return ret; }