status_t submit_tx_command(bt_usb_dev* bdev, snet_buffer* snbuf) { uint8 bRequestType = bdev->ctrl_req; uint8 bRequest = 0; uint16 wIndex = 0; uint16 value = 0; uint16 wLength = B_HOST_TO_LENDIAN_INT16(snb_size(snbuf)); status_t error; if (!GET_BIT(bdev->state, RUNNING)) { return B_DEV_NOT_READY; } // set cookie snb_set_cookie(snbuf, bdev); debugf("@%p\n", snb_get(snbuf)); error = usb->queue_request(bdev->dev, bRequestType, bRequest, value, wIndex, wLength, snb_get(snbuf), #ifndef HAIKU_TARGET_PLATFORM_HAIKU wLength, #endif command_complete, (void*) snbuf); if (error != B_OK) { bdev->stat.rejectedTX++; } else { bdev->stat.acceptedTX++; } return error; }
void PCL6Writer::Append(uint16 value) { int16 v = B_HOST_TO_LENDIAN_INT16(value); Append(BYTE_AT(v, 0)); Append(BYTE_AT(v, 1)); }
ssize_t QuickCamDevice::ReadIIC16(uint8 address, uint16 *data) { status_t err; uint8 buffer[0x23]; memset(buffer, 0, sizeof(buffer)); buffer[0x20] = Sensor() ? Sensor()->IICReadAddress() : 0; buffer[0x21] = 1 - 1; buffer[0x22] = 0x03; buffer[0] = address; err = SendCommand(USB_REQTYPE_DEVICE_OUT, 0x04, STV_I2C_WRITE, 0, 0x23, buffer); if (err < B_OK) return err; buffer[0] = 0xaa; buffer[1] = 0xaa; err = SendCommand(USB_REQTYPE_DEVICE_IN, 0x04, STV_I2C_READ, 0, 0x2, buffer); PRINT((CH ": SendCommand: %s" CT, strerror(err))); if (err < B_OK) return err; if (fChipIsBigEndian) *data = B_HOST_TO_BENDIAN_INT16(*(uint16 *)(&buffer[0])); else *data = B_HOST_TO_LENDIAN_INT16(*(uint16 *)(&buffer[0])); PRINT((CH ": 0x%04x" CT, *data)); return 2; }
// utf8 to LENDIAN unicode static status_t _utf8_to_lendian_unicode( const char *src, size_t *srcLen, char *dst, size_t *dstLen) { size_t srcLimit = *srcLen; size_t dstLimit = *dstLen - 1; size_t srcCount = 0; size_t dstCount = 0; status_t status = B_ERROR; while ((srcCount < srcLimit) && (dstCount < dstLimit)) { uint16 unicode; uint16 *UNICODE = &unicode; uchar *UTF8 = (uchar *)src + srcCount; int err_flag; if ((srcCount + utf8_char_len(src[srcCount])) > srcLimit) break; utf8_to_u_hostendian(UTF8, UNICODE, err_flag); if (err_flag == 1) return EINVAL; unicode = B_HOST_TO_LENDIAN_INT16(unicode); if ((dstCount + 1) > dstLimit) { status = B_BUFFER_OVERFLOW; break; } dst[dstCount++] = unicode & 0xFF; dst[dstCount++] = unicode >> 8; srcCount += UTF8 - ((uchar *)(src + srcCount)); status = B_OK; } *srcLen = srcCount; *dstLen = dstCount; return status; }
// utf8 to LENDIAN unicode static status_t _utf8_to_lendian_unicode( const char *src, int32 *srcLen, char *dst, uint32 *dstLen) { int32 srcLimit = *srcLen; int32 dstLimit = *dstLen - 1; int32 srcCount = 0; int32 dstCount = 0; while ((srcCount < srcLimit) && (dstCount < dstLimit)) { uint16 unicode; uint16 *UNICODE = &unicode; uchar *UTF8 = (uchar *)src + srcCount; int err_flag; if ((srcCount + utf8_char_len(src[srcCount])) > srcLimit) break; utf8_to_u_hostendian(UTF8, UNICODE, err_flag); if(err_flag == 1) return EINVAL; unicode = B_HOST_TO_LENDIAN_INT16(unicode); dst[dstCount++] = unicode & 0xFF; dst[dstCount++] = unicode >> 8; srcCount += UTF8 - ((uchar *)(src + srcCount)); } *srcLen = srcCount; *dstLen = dstCount; return ((dstCount > 0) ? B_NO_ERROR : B_ERROR); }
status_t Initialize(int fatbits, const char *device, const char *label, bool noprompt, bool testmode) { if (fatbits != 0 && fatbits != 12 && fatbits != 16 && fatbits != 32) { fprintf(stderr,"Error: don't know how to create a %d bit fat\n",fatbits); return B_ERROR; } //XXX the following two checks can be removed when this is fixed: #ifndef WITH_FLOPPY_SUPPORT if (0 != strstr(device,"floppy")) { fprintf(stderr,"Error: floppy B_GET_GEOMETRY and B_GET_BIOS_GEOMETRY calls are broken, floppy not supported\n"); return B_ERROR; } if (fatbits == 12) { fprintf(stderr,"Error: can't create a 12 bit fat on a device other than floppy\n"); return B_ERROR; } #endif printf("device = %s\n",device); int fd = open(device, O_RDWR); if (fd < 0) { fprintf(stderr, "Error: couldn't open file for device %s (%s)\n", device, strerror(errno)); return B_ERROR; } bool isRawDevice; bool hasBiosGeometry; bool hasDeviceGeometry; bool hasPartitionInfo; device_geometry biosGeometry; device_geometry deviceGeometry; partition_info partitionInfo; isRawDevice = 0 != strstr(device, "/raw"); hasBiosGeometry = B_OK == ioctl(fd, B_GET_BIOS_GEOMETRY, &biosGeometry, sizeof(biosGeometry)); hasDeviceGeometry = B_OK == ioctl(fd, B_GET_GEOMETRY, &deviceGeometry, sizeof(deviceGeometry)); hasPartitionInfo = B_OK == ioctl(fd, B_GET_PARTITION_INFO, &partitionInfo, sizeof(partitionInfo)); if (!isRawDevice && !hasBiosGeometry && !hasDeviceGeometry && !hasPartitionInfo) isRawDevice = true; if (hasBiosGeometry) { printf("bios geometry: %ld heads, %ld cylinders, %ld sectors/track, %ld bytes/sector\n", biosGeometry.head_count,biosGeometry.cylinder_count,biosGeometry.sectors_per_track,biosGeometry.bytes_per_sector); } if (hasBiosGeometry) { printf("device geometry: %ld heads, %ld cylinders, %ld sectors/track, %ld bytes/sector\n", deviceGeometry.head_count,deviceGeometry.cylinder_count,deviceGeometry.sectors_per_track,deviceGeometry.bytes_per_sector); } if (hasPartitionInfo) { printf("partition info: start at %Ld bytes (%Ld sectors), %Ld KB, %Ld MB, %Ld GB\n", partitionInfo.offset, partitionInfo.offset / 512, partitionInfo.offset / 1024, partitionInfo.offset / (1024 * 1024), partitionInfo.offset / (1024 * 1024 * 1024)); printf("partition info: size %Ld bytes, %Ld KB, %Ld MB, %Ld GB\n", partitionInfo.size, partitionInfo.size / 1024, partitionInfo.size / (1024 * 1024), partitionInfo.size / (1024 * 1024 * 1024)); } if (!isRawDevice && !hasPartitionInfo) { fprintf(stderr,"Warning: couldn't get partition information\n"); } if ((hasBiosGeometry && biosGeometry.bytes_per_sector != 512) || (hasDeviceGeometry && deviceGeometry.bytes_per_sector != 512)) { fprintf(stderr,"Error: geometry block size not 512 bytes\n"); close(fd); return B_ERROR; } else if (hasPartitionInfo && partitionInfo.logical_block_size != 512) { printf("partition logical block size is not 512, it's %ld bytes\n", partitionInfo.logical_block_size); } if (hasDeviceGeometry && deviceGeometry.read_only) { fprintf(stderr,"Error: this is a read-only device\n"); close(fd); return B_ERROR; } if (hasDeviceGeometry && deviceGeometry.write_once) { fprintf(stderr,"Error: this is a write-once device\n"); close(fd); return B_ERROR; } uint64 size = 0; if (hasPartitionInfo) { size = partitionInfo.size; } else if (hasDeviceGeometry) { size = uint64(deviceGeometry.bytes_per_sector) * deviceGeometry.sectors_per_track * deviceGeometry.cylinder_count * deviceGeometry.head_count; } else if (hasBiosGeometry) { size = uint64(biosGeometry.bytes_per_sector) * biosGeometry.sectors_per_track * biosGeometry.cylinder_count * biosGeometry.head_count; } else { // maybe it's just a file struct stat stat; if (fstat(fd, &stat) < 0) { fprintf(stderr, "Error: couldn't get device partition or geometry information, nor size\n"); close(fd); return B_ERROR; } size = stat.st_size; } // TODO still valid on Haiku ? /*if (isRawDevice && size > FLOPPY_MAX_SIZE) { fprintf(stderr,"Error: device too large for floppy, or raw devices not supported\n"); close(fd); return B_ERROR; }*/ printf("size = %Ld bytes (%Ld sectors), %Ld KB, %Ld MB, %Ld GB\n", size, size / 512, size / 1024, size / (1024 * 1024), size / (1024 * 1024 * 1024)); if (fatbits == 0) { //auto determine fat type if (isRawDevice && size <= FLOPPY_MAX_SIZE && (size / FAT12_CLUSTER_MAX_SIZE) < FAT12_MAX_CLUSTER_COUNT) { fatbits = 12; } else if ((size / CLUSTER_MAX_SIZE) < FAT16_MAX_CLUSTER_COUNT) { fatbits = 16; } else if ((size / CLUSTER_MAX_SIZE) < FAT32_MAX_CLUSTER_COUNT) { fatbits = 32; } } if (fatbits == 0) { fprintf(stderr,"Error: device too large for 32 bit fat\n"); close(fd); return B_ERROR; } int sectorPerCluster; sectorPerCluster = 0; if (fatbits == 12) { sectorPerCluster = 0; if (size <= 4182016LL) sectorPerCluster = 2; // XXX don't know the correct value if (size <= 2091008LL) sectorPerCluster = 1; // XXX don't know the correct value } else if (fatbits == 16) { // special BAD_CLUSTER value is 0xFFF7, // but this should work anyway, since space required by // two FATs will make maximum cluster count smaller. // at least, this is what I think *should* happen sectorPerCluster = 0; //larger than 2 GB must fail if (size <= (2048 * 1024 * 1024LL)) // up to 2GB, use 32k clusters sectorPerCluster = 64; if (size <= (1024 * 1024 * 1024LL)) // up to 1GB, use 16k clusters sectorPerCluster = 32; if (size <= (512 * 1024 * 1024LL)) // up to 512MB, use 8k clusters sectorPerCluster = 16; if (size <= (256 * 1024 * 1024LL)) // up to 256MB, use 4k clusters sectorPerCluster = 8; if (size <= (128 * 1024 * 1024LL)) // up to 128MB, use 2k clusters sectorPerCluster = 4; if (size <= (16 * 1024 * 1024LL)) // up to 16MB, use 2k clusters sectorPerCluster = 2; if (size <= 4182016LL) // smaller than fat32 must fail sectorPerCluster = 0; } if (fatbits == 32) { sectorPerCluster = 64; // default is 32k clusters if (size <= (32 * 1024 * 1024 * 1024LL)) // up to 32GB, use 16k clusters sectorPerCluster = 32; if (size <= (16 * 1024 * 1024 * 1024LL)) // up to 16GB, use 8k clusters sectorPerCluster = 16; if (size <= (8 * 1024 * 1024 * 1024LL)) // up to 8GB, use 4k clusters sectorPerCluster = 8; if (size <= (532480 * 512LL)) // up to 260 MB, use 0.5k clusters sectorPerCluster = 1; if (size <= (66600 * 512LL)) // smaller than 32.5 MB must fail sectorPerCluster = 0; } if (sectorPerCluster == 0) { fprintf(stderr,"Error: failed to determine sector per cluster value, partition too large for %d bit fat\n",fatbits); close(fd); return B_ERROR; } int reservedSectorCount = 0; // avoid compiler warning int rootEntryCount = 0; // avoid compiler warning int numFATs; int sectorSize; uint8 biosDriveId; // get bios drive-id, or use 0x80 if (B_OK != ioctl(fd, B_GET_BIOS_DRIVE_ID, &biosDriveId, sizeof(biosDriveId))) { biosDriveId = 0x80; } else { printf("bios drive id: 0x%02x\n", (int)biosDriveId); } // default parameters for the bootsector numFATs = 2; sectorSize = 512; if (fatbits == 12 || fatbits == 16) reservedSectorCount = 1; if (fatbits == 32) reservedSectorCount = 32; if (fatbits == 12) rootEntryCount = 128; // XXX don't know the correct value if (fatbits == 16) rootEntryCount = 512; if (fatbits == 32) rootEntryCount = 0; // Determine FATSize // calculation done as MS recommends uint64 dskSize = size / sectorSize; uint32 rootDirSectors = ((rootEntryCount * 32) + (sectorSize - 1)) / sectorSize; uint64 tmpVal1 = dskSize - (reservedSectorCount + rootDirSectors); uint64 tmpVal2 = (256 * sectorPerCluster) + numFATs; if (fatbits == 32) tmpVal2 = tmpVal2 / 2; uint32 FATSize = (tmpVal1 + (tmpVal2 - 1)) / tmpVal2; // FATSize should now contain the size of *one* FAT, measured in sectors // RootDirSectors should now contain the size of the fat12/16 root directory, measured in sectors printf("fatbits = %d, clustersize = %d\n", fatbits, sectorPerCluster * 512); printf("FAT size is %ld sectors\n", FATSize); printf("disk label: %s\n", label); char bootsector[512]; memset(bootsector,0x00,512); memcpy(bootsector + BOOTJMP_START_OFFSET, bootjmp, sizeof(bootjmp)); memcpy(bootsector + BOOTCODE_START_OFFSET, bootcode, sizeof(bootcode)); if (fatbits == 32) { bootsector32 *bs = (bootsector32 *)bootsector; uint16 temp16; uint32 temp32; memcpy(bs->BS_OEMName,"Haiku ",8); bs->BPB_BytsPerSec = B_HOST_TO_LENDIAN_INT16(sectorSize); bs->BPB_SecPerClus = sectorPerCluster; bs->BPB_RsvdSecCnt = B_HOST_TO_LENDIAN_INT16(reservedSectorCount); bs->BPB_NumFATs = numFATs; bs->BPB_RootEntCnt = B_HOST_TO_LENDIAN_INT16(rootEntryCount); bs->BPB_TotSec16 = B_HOST_TO_LENDIAN_INT16(0); bs->BPB_Media = 0xF8; bs->BPB_FATSz16 = B_HOST_TO_LENDIAN_INT16(0); temp16 = hasBiosGeometry ? biosGeometry.sectors_per_track : 63; bs->BPB_SecPerTrk = B_HOST_TO_LENDIAN_INT16(temp16); temp16 = hasBiosGeometry ? biosGeometry.head_count : 255; bs->BPB_NumHeads = B_HOST_TO_LENDIAN_INT16(temp16); temp32 = hasPartitionInfo ? (partitionInfo.size / 512) : 0; bs->BPB_HiddSec = B_HOST_TO_LENDIAN_INT32(temp32); temp32 = size / 512; bs->BPB_TotSec32 = B_HOST_TO_LENDIAN_INT32(temp32); bs->BPB_FATSz32 = B_HOST_TO_LENDIAN_INT32(FATSize); bs->BPB_ExtFlags = B_HOST_TO_LENDIAN_INT16(0); bs->BPB_FSVer = B_HOST_TO_LENDIAN_INT16(0); bs->BPB_RootClus = B_HOST_TO_LENDIAN_INT32(FAT32_ROOT_CLUSTER); bs->BPB_FSInfo = B_HOST_TO_LENDIAN_INT16(FSINFO_SECTOR_NUM); bs->BPB_BkBootSec = B_HOST_TO_LENDIAN_INT16(BACKUP_SECTOR_NUM); memset(bs->BPB_Reserved,0,12); bs->BS_DrvNum = biosDriveId; bs->BS_Reserved1 = 0x00; bs->BS_BootSig = 0x29; *(uint32*)bs->BS_VolID = (uint32)system_time(); memcpy(bs->BS_VolLab,"NO NAME ",11); memcpy(bs->BS_FilSysType,"FAT32 ",8); bs->signature = B_HOST_TO_LENDIAN_INT16(0xAA55); } else { bootsector1216 *bs = (bootsector1216 *)bootsector; uint16 temp16; uint32 temp32; uint32 sectorcount = size / 512; memcpy(bs->BS_OEMName, "Haiku ", 8); bs->BPB_BytsPerSec = B_HOST_TO_LENDIAN_INT16(sectorSize); bs->BPB_SecPerClus = sectorPerCluster; bs->BPB_RsvdSecCnt = B_HOST_TO_LENDIAN_INT16(reservedSectorCount); bs->BPB_NumFATs = numFATs; bs->BPB_RootEntCnt = B_HOST_TO_LENDIAN_INT16(rootEntryCount); temp16 = (sectorcount <= 65535) ? sectorcount : 0; bs->BPB_TotSec16 = B_HOST_TO_LENDIAN_INT16(temp16); bs->BPB_Media = 0xF8; bs->BPB_FATSz16 = B_HOST_TO_LENDIAN_INT16(FATSize); temp16 = hasBiosGeometry ? biosGeometry.sectors_per_track : 63; bs->BPB_SecPerTrk = B_HOST_TO_LENDIAN_INT16(temp16); temp16 = hasBiosGeometry ? biosGeometry.head_count : 255; bs->BPB_NumHeads = B_HOST_TO_LENDIAN_INT16(temp16); temp32 = hasPartitionInfo ? (partitionInfo.size / 512) : 0; bs->BPB_HiddSec = B_HOST_TO_LENDIAN_INT32(temp32); temp32 = (sectorcount <= 65535) ? 0 : sectorcount; bs->BPB_TotSec32 = B_HOST_TO_LENDIAN_INT32(temp32); bs->BS_DrvNum = biosDriveId; bs->BS_Reserved1 = 0x00; bs->BS_BootSig = 0x29; *(uint32*)bs->BS_VolID = (uint32)system_time(); memcpy(bs->BS_VolLab,"NO NAME ",11); memcpy(bs->BS_FilSysType,(fatbits == 12) ? "FAT12 " : "FAT16 ",8); bs->signature = B_HOST_TO_LENDIAN_INT16(0xAA55); } if (!noprompt) { printf("\n"); printf("Initializing will erase all existing data on the drive.\n"); printf("Do you wish to proceed? "); char answer[1000]; char *p; memset(answer, 0, 1000); fflush(stdout); p = fgets(answer, 1000, stdin); if (p && (p=strchr(p, '\n'))) *p = '\0'; /* remove newline */ if ((p == NULL) || (strlen(answer) < 1) || (0 != strncasecmp(answer, "yes", strlen(answer)))) { printf("drive NOT initialized\n"); close(fd); return B_OK; } } if (testmode) { close(fd); return B_OK; } // Disk layout: // 0) reserved sectors, this includes the bootsector, fsinfosector and bootsector backup // 1) FAT // 2) root directory (not on fat32) // 3) file & directory data ssize_t written; // initialize everything with zero first // avoid doing 512 byte writes here, they are slow printf("Writing FAT\n"); char * zerobuffer = (char *)malloc(65536); memset(zerobuffer,0,65536); int64 bytes_to_write = 512LL * (reservedSectorCount + (numFATs * FATSize) + rootDirSectors); int64 pos = 0; while (bytes_to_write > 0) { ssize_t writesize = min_c(bytes_to_write, 65536); written = write_pos(fd, pos, zerobuffer, writesize); if (written != writesize) { fprintf(stderr,"Error: write error near sector %Ld\n",pos / 512); close(fd); return B_ERROR; } bytes_to_write -= writesize; pos += writesize; } free(zerobuffer); //write boot sector printf("Writing boot block\n"); written = write_pos(fd, BOOT_SECTOR_NUM * 512, bootsector, 512); if (written != 512) { fprintf(stderr,"Error: write error at sector %d\n", BOOT_SECTOR_NUM); close(fd); return B_ERROR; } if (fatbits == 32) { written = write_pos(fd, BACKUP_SECTOR_NUM * 512, bootsector, 512); if (written != 512) { fprintf(stderr,"Error: write error at sector %d\n", BACKUP_SECTOR_NUM); close(fd); return B_ERROR; } } //write first fat sector printf("Writing first FAT sector\n"); uint8 sec[512]; memset(sec,0,512); if (fatbits == 12) { //FAT[0] contains media byte in lower 8 bits, all other bits set to 1 //FAT[1] contains EOF marker sec[0] = 0xF8; sec[1] = 0xFF; sec[2] = 0xFF; } else if (fatbits == 16) { //FAT[0] contains media byte in lower 8 bits, all other bits set to 1 sec[0] = 0xF8; sec[1] = 0xFF; //FAT[1] contains EOF marker sec[2] = 0xFF; sec[3] = 0xFF; } else if (fatbits == 32) { //FAT[0] contains media byte in lower 8 bits, all other bits set to 1 sec[0] = 0xF8; sec[1] = 0xFF; sec[2] = 0xFF; sec[3] = 0xFF; //FAT[1] contains EOF marker sec[4] = 0xFF; sec[5] = 0xFF; sec[6] = 0xFF; sec[7] = 0x0F; //FAT[2] contains EOF marker, used to terminate root directory sec[8] = 0xFF; sec[9] = 0xFF; sec[10] = 0xFF; sec[11] = 0x0F; } written = write_pos(fd, reservedSectorCount * 512, sec, 512); if (written != 512) { fprintf(stderr,"Error: write error at sector %d\n", reservedSectorCount); close(fd); return B_ERROR; } if (numFATs > 1) { written = write_pos(fd, (reservedSectorCount + FATSize) * 512,sec,512); if (written != 512) { fprintf(stderr,"Error: write error at sector %ld\n", reservedSectorCount + FATSize); close(fd); return B_ERROR; } } //write fsinfo sector if (fatbits == 32) { printf("Writing boot info\n"); //calculate total sector count first uint64 free_count = size / 512; //now account for already by metadata used sectors free_count -= reservedSectorCount + (numFATs * FATSize) + rootDirSectors; //convert from sector to clustercount free_count /= sectorPerCluster; //and account for 1 already used cluster of root directory free_count -= 1; fsinfosector32 fsinfosector; memset(&fsinfosector,0x00,512); fsinfosector.FSI_LeadSig = B_HOST_TO_LENDIAN_INT32(0x41615252); fsinfosector.FSI_StrucSig = B_HOST_TO_LENDIAN_INT32(0x61417272); fsinfosector.FSI_Free_Count = B_HOST_TO_LENDIAN_INT32((uint32)free_count); fsinfosector.FSI_Nxt_Free = B_HOST_TO_LENDIAN_INT32(3); fsinfosector.FSI_TrailSig = B_HOST_TO_LENDIAN_INT32(0xAA550000); written = write_pos(fd, FSINFO_SECTOR_NUM * 512, &fsinfosector, 512); if (written != 512) { fprintf(stderr,"Error: write error at sector %d\n", FSINFO_SECTOR_NUM); close(fd); return B_ERROR; } } //write volume label into root directory printf("Writing root directory\n"); if (fatbits == 12 || fatbits == 16) { uint8 data[512]; memset(data, 0, 512); CreateVolumeLabel(data, label); uint32 rootDirSector = reservedSectorCount + (numFATs * FATSize); written = write_pos(fd, rootDirSector * 512, data, 512); if (written != 512) { fprintf(stderr,"Error: write error at sector %ld\n", rootDirSector); close(fd); return B_ERROR; } } else if (fatbits == 32) { int size = 512 * sectorPerCluster; uint8 *cluster = (uint8*)malloc(size); memset(cluster, 0, size); CreateVolumeLabel(cluster, label); uint32 rootDirSector = reservedSectorCount + (numFATs * FATSize) + rootDirSectors; written = write_pos(fd, rootDirSector * 512, cluster, size); free(cluster); if (written != size) { fprintf(stderr,"Error: write error at sector %ld\n", rootDirSector); close(fd); return B_ERROR; } } ioctl(fd, B_FLUSH_DRIVE_CACHE); close(fd); return B_OK; }
void MemoryView::_GetNextHexBlock(char* buffer, int32 bufferSize, const char* address) { switch(fHexMode) { case HexMode8BitInt: { snprintf(buffer, bufferSize, "%02" B_PRIx8, *((const uint8*)address)); break; } case HexMode16BitInt: { uint16 data = *((const uint16*)address); switch(fCurrentEndianMode) { case EndianModeBigEndian: { data = B_HOST_TO_BENDIAN_INT16(data); } break; case EndianModeLittleEndian: { data = B_HOST_TO_LENDIAN_INT16(data); } break; } snprintf(buffer, bufferSize, "%04" B_PRIx16, data); break; } case HexMode32BitInt: { uint32 data = *((const uint32*)address); switch(fCurrentEndianMode) { case EndianModeBigEndian: { data = B_HOST_TO_BENDIAN_INT32(data); } break; case EndianModeLittleEndian: { data = B_HOST_TO_LENDIAN_INT32(data); } break; } snprintf(buffer, bufferSize, "%08" B_PRIx32, data); break; } case HexMode64BitInt: { uint64 data = *((const uint64*)address); switch(fCurrentEndianMode) { case EndianModeBigEndian: { data = B_HOST_TO_BENDIAN_INT64(data); } break; case EndianModeLittleEndian: { data = B_HOST_TO_LENDIAN_INT64(data); } break; } snprintf(buffer, bufferSize, "%0*" B_PRIx64, 16, data); break; } } }
status_t pll_set(uint8 pllID, uint32 pixelClock, uint8 crtcID) { uint32 connectorIndex = gDisplay[crtcID]->connectorIndex; pll_info *pll = &gConnector[connectorIndex]->encoder.pll; pll->pixelClock = pixelClock; pll->id = pllID; pll_setup_flags(pll, crtcID); // set up any special flags pll_adjust(pll, crtcID); // get any needed clock adjustments, set reference/post dividers pll_compute(pll); // compute dividers int index = GetIndexIntoMasterTable(COMMAND, SetPixelClock); union set_pixel_clock args; memset(&args, 0, sizeof(args)); uint8 tableMajor; uint8 tableMinor; atom_parse_cmd_header(gAtomContext, index, &tableMajor, &tableMinor); uint32 bitsPerChannel = 8; // TODO: Digital Depth, EDID 1.4+ on digital displays // isn't in Haiku edid common code? switch (tableMinor) { case 1: args.v1.usPixelClock = B_HOST_TO_LENDIAN_INT16(pll->pixelClock / 10); args.v1.usRefDiv = B_HOST_TO_LENDIAN_INT16(pll->referenceDiv); args.v1.usFbDiv = B_HOST_TO_LENDIAN_INT16(pll->feedbackDiv); args.v1.ucFracFbDiv = pll->feedbackDivFrac; args.v1.ucPostDiv = pll->postDiv; args.v1.ucPpll = pll->id; args.v1.ucCRTC = crtcID; args.v1.ucRefDivSrc = 1; break; case 2: args.v2.usPixelClock = B_HOST_TO_LENDIAN_INT16(pll->pixelClock / 10); args.v2.usRefDiv = B_HOST_TO_LENDIAN_INT16(pll->referenceDiv); args.v2.usFbDiv = B_HOST_TO_LENDIAN_INT16(pll->feedbackDiv); args.v2.ucFracFbDiv = pll->feedbackDivFrac; args.v2.ucPostDiv = pll->postDiv; args.v2.ucPpll = pll->id; args.v2.ucCRTC = crtcID; args.v2.ucRefDivSrc = 1; break; case 3: args.v3.usPixelClock = B_HOST_TO_LENDIAN_INT16(pll->pixelClock / 10); args.v3.usRefDiv = B_HOST_TO_LENDIAN_INT16(pll->referenceDiv); args.v3.usFbDiv = B_HOST_TO_LENDIAN_INT16(pll->feedbackDiv); args.v3.ucFracFbDiv = pll->feedbackDivFrac; args.v3.ucPostDiv = pll->postDiv; args.v3.ucPpll = pll->id; args.v3.ucMiscInfo = (pll->id << 2); // if (ss_enabled && (ss->type & ATOM_EXTERNAL_SS_MASK)) // args.v3.ucMiscInfo |= PIXEL_CLOCK_MISC_REF_DIV_SRC; args.v3.ucTransmitterId = gConnector[connectorIndex]->encoder.objectID; args.v3.ucEncoderMode = display_get_encoder_mode(connectorIndex); break; case 5: args.v5.ucCRTC = crtcID; args.v5.usPixelClock = B_HOST_TO_LENDIAN_INT16(pll->pixelClock / 10); args.v5.ucRefDiv = pll->referenceDiv; args.v5.usFbDiv = B_HOST_TO_LENDIAN_INT16(pll->feedbackDiv); args.v5.ulFbDivDecFrac = B_HOST_TO_LENDIAN_INT32(pll->feedbackDivFrac * 100000); args.v5.ucPostDiv = pll->postDiv; args.v5.ucMiscInfo = 0; /* HDMI depth, etc. */ // if (ss_enabled && (ss->type & ATOM_EXTERNAL_SS_MASK)) // args.v5.ucMiscInfo |= PIXEL_CLOCK_V5_MISC_REF_DIV_SRC; switch (bitsPerChannel) { case 8: default: args.v5.ucMiscInfo |= PIXEL_CLOCK_V5_MISC_HDMI_24BPP; break; case 10: args.v5.ucMiscInfo |= PIXEL_CLOCK_V5_MISC_HDMI_30BPP; break; } args.v5.ucTransmitterID = gConnector[connectorIndex]->encoder.objectID; args.v5.ucEncoderMode = display_get_encoder_mode(connectorIndex); args.v5.ucPpll = pllID; break; case 6: args.v6.ulDispEngClkFreq = B_HOST_TO_LENDIAN_INT32(crtcID << 24 | pll->pixelClock / 10); args.v6.ucRefDiv = pll->referenceDiv; args.v6.usFbDiv = B_HOST_TO_LENDIAN_INT16(pll->feedbackDiv); args.v6.ulFbDivDecFrac = B_HOST_TO_LENDIAN_INT32(pll->feedbackDivFrac * 100000); args.v6.ucPostDiv = pll->postDiv; args.v6.ucMiscInfo = 0; /* HDMI depth, etc. */ // if (ss_enabled && (ss->type & ATOM_EXTERNAL_SS_MASK)) // args.v6.ucMiscInfo |= PIXEL_CLOCK_V6_MISC_REF_DIV_SRC; switch (bitsPerChannel) { case 8: default: args.v6.ucMiscInfo |= PIXEL_CLOCK_V6_MISC_HDMI_24BPP; break; case 10: args.v6.ucMiscInfo |= PIXEL_CLOCK_V6_MISC_HDMI_30BPP; break; case 12: args.v6.ucMiscInfo |= PIXEL_CLOCK_V6_MISC_HDMI_36BPP; break; case 16: args.v6.ucMiscInfo |= PIXEL_CLOCK_V6_MISC_HDMI_48BPP; break; } args.v6.ucTransmitterID = gConnector[connectorIndex]->encoder.objectID; args.v6.ucEncoderMode = display_get_encoder_mode(connectorIndex); args.v6.ucPpll = pllID; break; default: TRACE("%s: ERROR: table version %" B_PRIu8 ".%" B_PRIu8 " TODO\n", __func__, tableMajor, tableMinor); return B_ERROR; } TRACE("%s: set adjusted pixel clock %" B_PRIu32 " (was %" B_PRIu32 ")\n", __func__, pll->pixelClock, pixelClock); return atom_execute_table(gAtomContext, index, (uint32*)&args); }
status_t pll_adjust(pll_info *pll, uint8 crtcID) { // TODO: PLL flags radeon_shared_info &info = *gInfo->shared_info; uint32 pixelClock = pll->pixelClock; // original as pixel_clock will be adjusted uint32 connectorIndex = gDisplay[crtcID]->connectorIndex; uint32 encoderID = gConnector[connectorIndex]->encoder.objectID; uint32 encoderMode = display_get_encoder_mode(connectorIndex); if (info.device_chipset >= (RADEON_R600 | 0x20)) { union adjust_pixel_clock args; uint8 tableMajor; uint8 tableMinor; int index = GetIndexIntoMasterTable(COMMAND, AdjustDisplayPll); if (atom_parse_cmd_header(gAtomContext, index, &tableMajor, &tableMinor) != B_OK) { return B_ERROR; } memset(&args, 0, sizeof(args)); switch (tableMajor) { case 1: switch (tableMinor) { case 1: case 2: args.v1.usPixelClock = B_HOST_TO_LENDIAN_INT16(pixelClock / 10); args.v1.ucTransmitterID = encoderID; args.v1.ucEncodeMode = encoderMode; // TODO: SS and SS % > 0 if (0) { args.v1.ucConfig |= ADJUST_DISPLAY_CONFIG_SS_ENABLE; } atom_execute_table(gAtomContext, index, (uint32*)&args); // get returned adjusted clock pll->pixelClock = B_LENDIAN_TO_HOST_INT16(args.v1.usPixelClock); pll->pixelClock *= 10; break; case 3: args.v3.sInput.usPixelClock = B_HOST_TO_LENDIAN_INT16(pixelClock / 10); args.v3.sInput.ucTransmitterID = encoderID; args.v3.sInput.ucEncodeMode = encoderMode; args.v3.sInput.ucDispPllConfig = 0; // TODO: SS and SS % > 0 if (0) { args.v3.sInput.ucDispPllConfig |= DISPPLL_CONFIG_SS_ENABLE; } // TODO: if ATOM_DEVICE_DFP_SUPPORT // TODO: display port DP // TODO: is DP? args.v3.sInput.ucExtTransmitterID = 0; atom_execute_table(gAtomContext, index, (uint32*)&args); // get returned adjusted clock pll->pixelClock = B_LENDIAN_TO_HOST_INT32( args.v3.sOutput.ulDispPllFreq); pll->pixelClock *= 10; // convert to kHz for storage if (args.v3.sOutput.ucRefDiv) { pll->flags |= PLL_USE_FRAC_FB_DIV; pll->flags |= PLL_USE_REF_DIV; pll->referenceDiv = args.v3.sOutput.ucRefDiv; } if (args.v3.sOutput.ucPostDiv) { pll->flags |= PLL_USE_FRAC_FB_DIV; pll->flags |= PLL_USE_POST_DIV; pll->postDiv = args.v3.sOutput.ucPostDiv; } break; default: TRACE("%s: ERROR: table version %" B_PRIu8 ".%" B_PRIu8 " unknown\n", __func__, tableMajor, tableMinor); return B_ERROR; } break; default: TRACE("%s: ERROR: table version %" B_PRIu8 ".%" B_PRIu8 " unknown\n", __func__, tableMajor, tableMinor); return B_ERROR; } } TRACE("%s: was: %" B_PRIu32 ", now: %" B_PRIu32 "\n", __func__, pixelClock, pll->pixelClock); return B_OK; }
status_t pll_external_set(uint32 clock) { TRACE("%s: set external pll clock to %" B_PRIu32 "\n", __func__, clock); if (clock == 0) ERROR("%s: Warning: default display clock is 0?\n", __func__); // also known as PLL display engineering uint8 tableMajor; uint8 tableMinor; int index = GetIndexIntoMasterTable(COMMAND, SetPixelClock); atom_parse_cmd_header(gAtomContext, index, &tableMajor, &tableMinor); TRACE("%s: table %" B_PRIu8 ".%" B_PRIu8 "\n", __func__, tableMajor, tableMinor); union setPixelClock { SET_PIXEL_CLOCK_PS_ALLOCATION base; PIXEL_CLOCK_PARAMETERS v1; PIXEL_CLOCK_PARAMETERS_V2 v2; PIXEL_CLOCK_PARAMETERS_V3 v3; PIXEL_CLOCK_PARAMETERS_V5 v5; PIXEL_CLOCK_PARAMETERS_V6 v6; }; union setPixelClock args; memset(&args, 0, sizeof(args)); radeon_shared_info &info = *gInfo->shared_info; uint32 dceVersion = (info.dceMajor * 100) + info.dceMinor; switch (tableMajor) { case 1: switch(tableMinor) { case 5: // If the default DC PLL clock is specified, // SetPixelClock provides the dividers. args.v5.ucCRTC = ATOM_CRTC_INVALID; args.v5.usPixelClock = B_HOST_TO_LENDIAN_INT16(clock / 10); args.v5.ucPpll = ATOM_DCPLL; break; case 6: // If the default DC PLL clock is specified, // SetPixelClock provides the dividers. args.v6.ulDispEngClkFreq = B_HOST_TO_LENDIAN_INT32(clock / 10); if (dceVersion == 601) args.v6.ucPpll = ATOM_EXT_PLL1; else if (dceVersion >= 600) args.v6.ucPpll = ATOM_PPLL0; else args.v6.ucPpll = ATOM_DCPLL; break; default: ERROR("%s: Unknown table version %" B_PRIu8 ".%" B_PRIu8 "\n", __func__, tableMajor, tableMinor); } break; default: ERROR("%s: Unknown table version %" B_PRIu8 ".%" B_PRIu8 "\n", __func__, tableMajor, tableMinor); } return B_OK; }
status_t pll_set(display_mode* mode, uint8 crtcID) { uint32 connectorIndex = gDisplay[crtcID]->connectorIndex; pll_info* pll = &gConnector[connectorIndex]->encoder.pll; uint32 dp_clock = gConnector[connectorIndex]->dpInfo.linkRate; bool ssEnabled = false; pll->pixelClock = mode->timing.pixel_clock; radeon_shared_info &info = *gInfo->shared_info; // Probe for PLL spread spectrum info; pll->ssPercentage = 0; pll->ssType = 0; pll->ssStep = 0; pll->ssDelay = 0; pll->ssRange = 0; pll->ssReferenceDiv = 0; switch (display_get_encoder_mode(connectorIndex)) { case ATOM_ENCODER_MODE_DP_MST: case ATOM_ENCODER_MODE_DP: if (info.dceMajor >= 4) pll_asic_ss_probe(pll, ASIC_INTERNAL_SS_ON_DP); else { if (dp_clock == 162000) { ssEnabled = pll_ppll_ss_probe(pll, ATOM_DP_SS_ID2); if (!ssEnabled) // id2 failed, try id1 ssEnabled = pll_ppll_ss_probe(pll, ATOM_DP_SS_ID1); } else ssEnabled = pll_ppll_ss_probe(pll, ATOM_DP_SS_ID1); } break; case ATOM_ENCODER_MODE_LVDS: if (info.dceMajor >= 4) ssEnabled = pll_asic_ss_probe(pll, gInfo->lvdsSpreadSpectrumID); else ssEnabled = pll_ppll_ss_probe(pll, gInfo->lvdsSpreadSpectrumID); break; case ATOM_ENCODER_MODE_DVI: if (info.dceMajor >= 4) ssEnabled = pll_asic_ss_probe(pll, ASIC_INTERNAL_SS_ON_TMDS); break; case ATOM_ENCODER_MODE_HDMI: if (info.dceMajor >= 4) ssEnabled = pll_asic_ss_probe(pll, ASIC_INTERNAL_SS_ON_HDMI); break; } pll_setup_flags(pll, crtcID); // set up any special flags pll_adjust(pll, mode, crtcID); // get any needed clock adjustments, set reference/post dividers pll_compute(pll); // compute dividers display_crtc_ss(pll, ATOM_DISABLE); // disable ss uint8 tableMajor; uint8 tableMinor; int index = GetIndexIntoMasterTable(COMMAND, SetPixelClock); atom_parse_cmd_header(gAtomContext, index, &tableMajor, &tableMinor); TRACE("%s: table %" B_PRIu8 ".%" B_PRIu8 "\n", __func__, tableMajor, tableMinor); uint32 bitsPerColor = 8; // TODO: Digital Depth, EDID 1.4+ on digital displays // isn't in Haiku edid common code? // Prepare arguments for AtomBIOS call union setPixelClock { SET_PIXEL_CLOCK_PS_ALLOCATION base; PIXEL_CLOCK_PARAMETERS v1; PIXEL_CLOCK_PARAMETERS_V2 v2; PIXEL_CLOCK_PARAMETERS_V3 v3; PIXEL_CLOCK_PARAMETERS_V5 v5; PIXEL_CLOCK_PARAMETERS_V6 v6; }; union setPixelClock args; memset(&args, 0, sizeof(args)); switch (tableMinor) { case 1: args.v1.usPixelClock = B_HOST_TO_LENDIAN_INT16(pll->pixelClock / 10); args.v1.usRefDiv = B_HOST_TO_LENDIAN_INT16(pll->referenceDiv); args.v1.usFbDiv = B_HOST_TO_LENDIAN_INT16(pll->feedbackDiv); args.v1.ucFracFbDiv = pll->feedbackDivFrac; args.v1.ucPostDiv = pll->postDiv; args.v1.ucPpll = pll->id; args.v1.ucCRTC = crtcID; args.v1.ucRefDivSrc = 1; break; case 2: args.v2.usPixelClock = B_HOST_TO_LENDIAN_INT16(pll->pixelClock / 10); args.v2.usRefDiv = B_HOST_TO_LENDIAN_INT16(pll->referenceDiv); args.v2.usFbDiv = B_HOST_TO_LENDIAN_INT16(pll->feedbackDiv); args.v2.ucFracFbDiv = pll->feedbackDivFrac; args.v2.ucPostDiv = pll->postDiv; args.v2.ucPpll = pll->id; args.v2.ucCRTC = crtcID; args.v2.ucRefDivSrc = 1; break; case 3: args.v3.usPixelClock = B_HOST_TO_LENDIAN_INT16(pll->pixelClock / 10); args.v3.usRefDiv = B_HOST_TO_LENDIAN_INT16(pll->referenceDiv); args.v3.usFbDiv = B_HOST_TO_LENDIAN_INT16(pll->feedbackDiv); args.v3.ucFracFbDiv = pll->feedbackDivFrac; args.v3.ucPostDiv = pll->postDiv; args.v3.ucPpll = pll->id; args.v3.ucMiscInfo = (pll->id << 2); if (pll->ssPercentage > 0 && (pll->ssType & ATOM_EXTERNAL_SS_MASK) != 0) { args.v3.ucMiscInfo |= PIXEL_CLOCK_MISC_REF_DIV_SRC; } args.v3.ucTransmitterId = gConnector[connectorIndex]->encoder.objectID; args.v3.ucEncoderMode = display_get_encoder_mode(connectorIndex); break; case 5: args.v5.ucCRTC = crtcID; args.v5.usPixelClock = B_HOST_TO_LENDIAN_INT16(pll->pixelClock / 10); args.v5.ucRefDiv = pll->referenceDiv; args.v5.usFbDiv = B_HOST_TO_LENDIAN_INT16(pll->feedbackDiv); args.v5.ulFbDivDecFrac = B_HOST_TO_LENDIAN_INT32(pll->feedbackDivFrac * 100000); args.v5.ucPostDiv = pll->postDiv; args.v5.ucMiscInfo = 0; /* HDMI depth, etc. */ if (pll->ssPercentage > 0 && (pll->ssType & ATOM_EXTERNAL_SS_MASK) != 0) { args.v5.ucMiscInfo |= PIXEL_CLOCK_V5_MISC_REF_DIV_SRC; } switch (bitsPerColor) { case 8: default: args.v5.ucMiscInfo |= PIXEL_CLOCK_V5_MISC_HDMI_24BPP; break; case 10: args.v5.ucMiscInfo |= PIXEL_CLOCK_V5_MISC_HDMI_30BPP; break; } args.v5.ucTransmitterID = gConnector[connectorIndex]->encoder.objectID; args.v5.ucEncoderMode = display_get_encoder_mode(connectorIndex); args.v5.ucPpll = pll->id; break; case 6: args.v6.ulDispEngClkFreq = B_HOST_TO_LENDIAN_INT32(crtcID << 24 | pll->pixelClock / 10); args.v6.ucRefDiv = pll->referenceDiv; args.v6.usFbDiv = B_HOST_TO_LENDIAN_INT16(pll->feedbackDiv); args.v6.ulFbDivDecFrac = B_HOST_TO_LENDIAN_INT32(pll->feedbackDivFrac * 100000); args.v6.ucPostDiv = pll->postDiv; args.v6.ucMiscInfo = 0; /* HDMI depth, etc. */ if (pll->ssPercentage > 0 && (pll->ssType & ATOM_EXTERNAL_SS_MASK) != 0) { args.v6.ucMiscInfo |= PIXEL_CLOCK_V6_MISC_REF_DIV_SRC; } switch (bitsPerColor) { case 8: default: args.v6.ucMiscInfo |= PIXEL_CLOCK_V6_MISC_HDMI_24BPP; break; case 10: args.v6.ucMiscInfo |= PIXEL_CLOCK_V6_MISC_HDMI_30BPP; break; case 12: args.v6.ucMiscInfo |= PIXEL_CLOCK_V6_MISC_HDMI_36BPP; break; case 16: args.v6.ucMiscInfo |= PIXEL_CLOCK_V6_MISC_HDMI_48BPP; break; } args.v6.ucTransmitterID = gConnector[connectorIndex]->encoder.objectID; args.v6.ucEncoderMode = display_get_encoder_mode(connectorIndex); args.v6.ucPpll = pll->id; break; default: TRACE("%s: ERROR: table version %" B_PRIu8 ".%" B_PRIu8 " TODO\n", __func__, tableMajor, tableMinor); return B_ERROR; } TRACE("%s: set adjusted pixel clock %" B_PRIu32 " (was %" B_PRIu32 ")\n", __func__, pll->pixelClock, mode->timing.pixel_clock); status_t result = atom_execute_table(gAtomContext, index, (uint32*)&args); if (ssEnabled) display_crtc_ss(pll, ATOM_ENABLE); return result; }
status_t pll_adjust(pll_info* pll, display_mode* mode, uint8 crtcID) { radeon_shared_info &info = *gInfo->shared_info; uint32 pixelClock = pll->pixelClock; // original as pixel_clock will be adjusted uint32 connectorIndex = gDisplay[crtcID]->connectorIndex; connector_info* connector = gConnector[connectorIndex]; uint32 encoderID = connector->encoder.objectID; uint32 encoderMode = display_get_encoder_mode(connectorIndex); uint32 connectorFlags = connector->flags; uint32 externalEncoderID = 0; pll->adjustedClock = pll->pixelClock; if (connector->encoderExternal.isDPBridge) externalEncoderID = connector->encoderExternal.objectID; if (info.dceMajor >= 3) { uint8 tableMajor; uint8 tableMinor; int index = GetIndexIntoMasterTable(COMMAND, AdjustDisplayPll); if (atom_parse_cmd_header(gAtomContext, index, &tableMajor, &tableMinor) != B_OK) { ERROR("%s: Couldn't find AtomBIOS PLL adjustment\n", __func__); return B_ERROR; } TRACE("%s: table %" B_PRIu8 ".%" B_PRIu8 "\n", __func__, tableMajor, tableMinor); // Prepare arguments for AtomBIOS call union adjustPixelClock { ADJUST_DISPLAY_PLL_PS_ALLOCATION v1; ADJUST_DISPLAY_PLL_PS_ALLOCATION_V3 v3; }; union adjustPixelClock args; memset(&args, 0, sizeof(args)); switch (tableMajor) { case 1: switch (tableMinor) { case 1: case 2: args.v1.usPixelClock = B_HOST_TO_LENDIAN_INT16(pixelClock / 10); args.v1.ucTransmitterID = encoderID; args.v1.ucEncodeMode = encoderMode; if (pll->ssPercentage > 0) { args.v1.ucConfig |= ADJUST_DISPLAY_CONFIG_SS_ENABLE; } atom_execute_table(gAtomContext, index, (uint32*)&args); // get returned adjusted clock pll->adjustedClock = B_LENDIAN_TO_HOST_INT16(args.v1.usPixelClock); pll->adjustedClock *= 10; break; case 3: args.v3.sInput.usPixelClock = B_HOST_TO_LENDIAN_INT16(pixelClock / 10); args.v3.sInput.ucTransmitterID = encoderID; args.v3.sInput.ucEncodeMode = encoderMode; args.v3.sInput.ucDispPllConfig = 0; if (pll->ssPercentage > 0) { args.v3.sInput.ucDispPllConfig |= DISPPLL_CONFIG_SS_ENABLE; } // Handle DP adjustments if (encoderMode == ATOM_ENCODER_MODE_DP || encoderMode == ATOM_ENCODER_MODE_DP_MST) { TRACE("%s: encoderMode is DP\n", __func__); args.v3.sInput.ucDispPllConfig |= DISPPLL_CONFIG_COHERENT_MODE; /* 162000 or 270000 */ uint32 dpLinkSpeed = dp_get_link_rate(connectorIndex, mode); /* 16200 or 27000 */ args.v3.sInput.usPixelClock = B_HOST_TO_LENDIAN_INT16(dpLinkSpeed / 10); } else if ((connectorFlags & ATOM_DEVICE_DFP_SUPPORT) != 0) { #if 0 if (encoderMode == ATOM_ENCODER_MODE_HDMI) { /* deep color support */ args.v3.sInput.usPixelClock = cpu_to_le16((mode->clock * bpc / 8) / 10); } #endif if (pixelClock > 165000) { args.v3.sInput.ucDispPllConfig |= DISPPLL_CONFIG_DUAL_LINK; } if (1) { // dig coherent mode? args.v3.sInput.ucDispPllConfig |= DISPPLL_CONFIG_COHERENT_MODE; } } args.v3.sInput.ucExtTransmitterID = externalEncoderID; atom_execute_table(gAtomContext, index, (uint32*)&args); // get returned adjusted clock pll->adjustedClock = B_LENDIAN_TO_HOST_INT32( args.v3.sOutput.ulDispPllFreq); pll->adjustedClock *= 10; // convert to kHz for storage if (args.v3.sOutput.ucRefDiv) { pll->flags |= PLL_USE_FRAC_FB_DIV; pll->flags |= PLL_USE_REF_DIV; pll->referenceDiv = args.v3.sOutput.ucRefDiv; } if (args.v3.sOutput.ucPostDiv) { pll->flags |= PLL_USE_FRAC_FB_DIV; pll->flags |= PLL_USE_POST_DIV; pll->postDiv = args.v3.sOutput.ucPostDiv; } break; default: TRACE("%s: ERROR: table version %" B_PRIu8 ".%" B_PRIu8 " unknown\n", __func__, tableMajor, tableMinor); return B_ERROR; } break; default: TRACE("%s: ERROR: table version %" B_PRIu8 ".%" B_PRIu8 " unknown\n", __func__, tableMajor, tableMinor); return B_ERROR; } } TRACE("%s: was: %" B_PRIu32 ", now: %" B_PRIu32 "\n", __func__, pixelClock, pll->adjustedClock); return B_OK; }