bool katou(const char *str, unsigned int *out)
{
int len = strlen(str);
int readlen;
int r = ksscanf(str, "%u%n", out, &readlen);
return r == 1 && readlen == len;
}
bool katoi(const char *str, int *out)
{
int len = strlen(str);
int readlen;
int r = ksscanf(str, "%d%n", out, &readlen);
return r == 1 && readlen == len;
}
/*
* Mount (mountfrom) as the root filesystem.
*/
static int
vfs_mountroot_try(const char *mountfrom)
{
struct mount *mp;
char *vfsname, *devname;
int error;
char patt[32];
const char *cp, *ep;
char *mf;
vfsname = NULL;
devname = NULL;
mp = NULL;
error = EINVAL;
if (mountfrom == NULL)
return(error); /* don't complain */
crit_enter();
kprintf("Mounting root from %s\n", mountfrom);
crit_exit();
cp = mountfrom;
/* parse vfs name and devname */
vfsname = kmalloc(MFSNAMELEN, M_MOUNT, M_WAITOK);
devname = kmalloc(MNAMELEN, M_MOUNT, M_WAITOK);
mf = kmalloc(MFSNAMELEN+MNAMELEN, M_MOUNT, M_WAITOK);
for(;;) {
for (ep = cp; (*ep != 0) && (*ep != ';'); ep++);
bzero(vfsname, MFSNAMELEN);
bzero(devname, MNAMELEN);
bzero(mf, MFSNAMELEN+MNAMELEN);
strncpy(mf, cp, MFSNAMELEN+MNAMELEN);
vfsname[0] = devname[0] = 0;
ksprintf(patt, "%%%d[a-z0-9]:%%%ds", MFSNAMELEN, MNAMELEN);
if (ksscanf(mf, patt, vfsname, devname) < 1)
goto end;
/* allocate a root mount */
error = vfs_rootmountalloc(vfsname,
devname[0] != 0 ? devname : ROOTNAME, &mp);
if (error != 0) {
kprintf("Can't allocate root mount for filesystem '%s': %d\n",
vfsname, error);
goto end;
}
mp->mnt_flag |= MNT_ROOTFS;
/* do our best to set rootdev */
if ((strcmp(vfsname, "hammer") != 0) && (devname[0] != 0) &&
setrootbyname(devname))
kprintf("setrootbyname failed\n");
/* If the root device is a type "memory disk", mount RW */
if (rootdev != NULL && dev_is_good(rootdev) &&
(dev_dflags(rootdev) & D_MEMDISK)) {
mp->mnt_flag &= ~MNT_RDONLY;
}
error = VFS_MOUNT(mp, NULL, NULL, proc0.p_ucred);
if (!error)
break;
end:
if(*ep == 0)
break;
cp = ep + 1;
}
if (vfsname != NULL)
kfree(vfsname, M_MOUNT);
if (devname != NULL)
kfree(devname, M_MOUNT);
if (mf != NULL)
kfree(mf, M_MOUNT);
if (error == 0) {
/* register with list of mounted filesystems */
mountlist_insert(mp, MNTINS_FIRST);
/* sanity check system clock against root fs timestamp */
inittodr(mp->mnt_time);
vfs_unbusy(mp);
if (mp->mnt_syncer == NULL) {
error = vfs_allocate_syncvnode(mp);
if (error)
kprintf("Warning: no syncer vp for root!\n");
error = 0;
}
} else {
if (mp != NULL) {
vfs_unbusy(mp);
kfree(mp, M_MOUNT);
}
kprintf("Root mount failed: %d\n", error);
}
return(error);
}
/**
* radeon_vce_init - allocate memory, load vce firmware
*
* @rdev: radeon_device pointer
*
* First step to get VCE online, allocate memory and load the firmware
*/
int radeon_vce_init(struct radeon_device *rdev)
{
static const char *fw_version = "[ATI LIB=VCEFW,";
static const char *fb_version = "[ATI LIB=VCEFWSTATS,";
unsigned long size;
const char *fw_name, *c;
uint8_t start, mid, end;
int i, r;
INIT_DELAYED_WORK(&rdev->vce.idle_work, radeon_vce_idle_work_handler);
switch (rdev->family) {
case CHIP_BONAIRE:
case CHIP_KAVERI:
case CHIP_KABINI:
case CHIP_HAWAII:
case CHIP_MULLINS:
fw_name = FIRMWARE_BONAIRE;
break;
default:
return -EINVAL;
}
r = request_firmware(&rdev->vce_fw, fw_name, rdev->dev);
if (r) {
dev_err(rdev->dev, "radeon_vce: Can't load firmware \"%s\"\n",
fw_name);
return r;
}
/* search for firmware version */
size = rdev->vce_fw->datasize - strlen(fw_version) - 9;
c = rdev->vce_fw->data;
for (;size > 0; --size, ++c)
if (strncmp(c, fw_version, strlen(fw_version)) == 0)
break;
if (size == 0)
return -EINVAL;
c += strlen(fw_version);
if (ksscanf(c, "%2hhd.%2hhd.%2hhd]", &start, &mid, &end) != 3)
return -EINVAL;
/* search for feedback version */
size = rdev->vce_fw->datasize - strlen(fb_version) - 3;
c = rdev->vce_fw->data;
for (;size > 0; --size, ++c)
if (strncmp(c, fb_version, strlen(fb_version)) == 0)
break;
if (size == 0)
return -EINVAL;
c += strlen(fb_version);
if (ksscanf(c, "%2u]", &rdev->vce.fb_version) != 1)
return -EINVAL;
DRM_INFO("Found VCE firmware/feedback version %hhd.%hhd.%hhd / %d!\n",
start, mid, end, rdev->vce.fb_version);
rdev->vce.fw_version = (start << 24) | (mid << 16) | (end << 8);
/* we can only work with this fw version for now */
if (rdev->vce.fw_version != ((40 << 24) | (2 << 16) | (2 << 8)))
return -EINVAL;
/* allocate firmware, stack and heap BO */
size = RADEON_GPU_PAGE_ALIGN(rdev->vce_fw->datasize) +
RADEON_VCE_STACK_SIZE + RADEON_VCE_HEAP_SIZE;
r = radeon_bo_create(rdev, size, PAGE_SIZE, true,
RADEON_GEM_DOMAIN_VRAM, 0, NULL, &rdev->vce.vcpu_bo);
if (r) {
dev_err(rdev->dev, "(%d) failed to allocate VCE bo\n", r);
return r;
}
r = radeon_bo_reserve(rdev->vce.vcpu_bo, false);
if (r) {
radeon_bo_unref(&rdev->vce.vcpu_bo);
dev_err(rdev->dev, "(%d) failed to reserve VCE bo\n", r);
return r;
}
r = radeon_bo_pin(rdev->vce.vcpu_bo, RADEON_GEM_DOMAIN_VRAM,
&rdev->vce.gpu_addr);
radeon_bo_unreserve(rdev->vce.vcpu_bo);
if (r) {
radeon_bo_unref(&rdev->vce.vcpu_bo);
dev_err(rdev->dev, "(%d) VCE bo pin failed\n", r);
return r;
}
for (i = 0; i < RADEON_MAX_VCE_HANDLES; ++i) {
atomic_set(&rdev->vce.handles[i], 0);
rdev->vce.filp[i] = NULL;
}
return 0;
}
