static bool ethtool_convert_link_mode_to_legacy_u32(u32 *legacy_u32, const unsigned long *src) { bool retval = true; /* TODO: following test will soon always be true */ if (__ETHTOOL_LINK_MODE_MASK_NBITS > 32) { __ETHTOOL_DECLARE_LINK_MODE_MASK(ext); bitmap_zero(ext, __ETHTOOL_LINK_MODE_MASK_NBITS); bitmap_fill(ext, 32); bitmap_complement(ext, ext, __ETHTOOL_LINK_MODE_MASK_NBITS); if (bitmap_intersects(ext, src, __ETHTOOL_LINK_MODE_MASK_NBITS)) { /* src mask goes beyond bit 31 */ retval = false; } } *legacy_u32 = src[0]; return retval; }
/* convert S390CPUDef into a static CpuModelInfo */ static void cpu_info_from_model(CpuModelInfo *info, const S390CPUModel *model, bool delta_changes) { QDict *qdict = qdict_new(); S390FeatBitmap bitmap; /* always fallback to the static base model */ info->name = g_strdup_printf("%s-base", model->def->name); if (delta_changes) { /* features deleted from the base feature set */ bitmap_andnot(bitmap, model->def->base_feat, model->features, S390_FEAT_MAX); if (!bitmap_empty(bitmap, S390_FEAT_MAX)) { s390_feat_bitmap_to_ascii(bitmap, qdict, qdict_add_disabled_feat); } /* features added to the base feature set */ bitmap_andnot(bitmap, model->features, model->def->base_feat, S390_FEAT_MAX); if (!bitmap_empty(bitmap, S390_FEAT_MAX)) { s390_feat_bitmap_to_ascii(bitmap, qdict, qdict_add_enabled_feat); } } else { /* expand all features */ s390_feat_bitmap_to_ascii(model->features, qdict, qdict_add_enabled_feat); bitmap_complement(bitmap, model->features, S390_FEAT_MAX); s390_feat_bitmap_to_ascii(bitmap, qdict, qdict_add_disabled_feat); } if (!qdict_size(qdict)) { QDECREF(qdict); } else { info->props = QOBJECT(qdict); info->has_props = true; } }
int tricam_process(int argc, char *argv[]) { int i, j, w, h, bpp; bytemap_t *up_image, *mid_image, *dn_image; bytemap_t *gray, *se; bitmap_t *up_roi, *mid_roi, *dn_roi; bitmap_t *bin, *roi, *tmp; char *fn, *ptr; real_t value; FILE *fd; label_info_t *label_info; dwordmap_t *labelmap; point_t *centroid; int label, area; uint8_t vmin, vmax; real_t vmean; bytemap_t *op1, *op2, *op3; char *path; int next_option; char *token1, *token2, *token3; real_t cutup = -2550000, cutdown = -4748; program_name = argv[0]; do { next_option = getopt_long(argc, argv, short_options, long_options, NULL); switch (next_option) { case 'h': print_usage(stdout, 0); break; case 'o': token1 = strdup(optarg); break; case 's': token2 = strdup(optarg); break; case 'd': token3 = strdup(optarg); break; case 'f': cutup = strtod(optarg, NULL); break; case 't': cutdown = strtod(optarg, NULL); break; case 'v': verbose = 1; break; case 'n': path = strdup(optarg); break; case '?': print_usage(stderr, 1); break; case -1: break; default: abort(); } } while (next_option != -1); // printf("(%s - %s) / %s, %lf, %lf, %s\n", token1, token2, token3, cutup, cutdown, path); w = WIDTH; h = HEIGHT; bpp = BPP; initialize_screen(w, h, bpp); up_image = bytemap_new(w, h); mid_image = bytemap_new(w, h); dn_image = bytemap_new(w, h); gray = bytemap_new(w, h); up_roi = bitmap_new(w, h); mid_roi = bitmap_new(w, h); dn_roi = bitmap_new(w, h); bin = bitmap_new(w, h); tmp = bitmap_new(w, h); roi = bitmap_new(w, h); se = bytemap_new(3, 3); bytemap_fill(se, 0, 0, 3, 3, 1); labelmap = dwordmap_new(w, h); path = (char *)malloc(256 * sizeof(char)); // Up display image //////////////////// strcpy(path, argv[1]); strcat(path, "_up.bmp"); fn = strrchr(path, '/') + 1; printf("Filename: %s\n", fn); printf("Display image\n"); load_and_display_BMP(path); read_bytemap_in_screen(up_image, NULL, NULL); bytemap_clear(gray); bytemap_copy(gray, UP_DX, UP_DY, up_image, 0, 0, w, h); write_bytemap_to_screen(gray, gray, gray); wait_keyhit(); printf("Mean filtering \n"); mean_smooth(up_image, gray, 3); write_bytemap_to_screen(up_image, up_image, up_image); wait_keyhit(); //////////////////////////////////////// // MID display image /////////////////// strcpy(path, argv[1]); strcat(path, "_mid.bmp"); fn = strrchr(path, '/') + 1; printf("Filename: %s\n", fn); printf("Display image\n"); load_and_display_BMP(path); read_bytemap_in_screen(mid_image, NULL, NULL); bytemap_clear(gray); bytemap_copy(gray, MID_DX, MID_DY, mid_image, 0, 0, w, h); write_bytemap_to_screen(gray, gray, gray); wait_keyhit(); printf("Mean filtering \n"); mean_smooth(mid_image, gray, 3); write_bytemap_to_screen(mid_image, mid_image, mid_image); wait_keyhit(); ///////////////////////////////////////// // DN display image ///////////////////// strcpy(path, argv[1]); strcat(path, "_dn.bmp"); fn = strrchr(path, '/') + 1; printf("filename: %s\n", fn); printf("Display image\n"); load_and_display_BMP(path); read_bytemap_in_screen(dn_image, NULL, NULL); bytemap_clear(gray); bytemap_copy(gray, DN_DX, DN_DY, dn_image, 0, 0, w, h); write_bytemap_to_screen(gray, gray, gray); wait_keyhit(); printf("Mean filtering \n"); mean_smooth(dn_image, gray, 3); write_bytemap_to_screen(dn_image, dn_image, dn_image); wait_keyhit(); /////////////////////////////////////// printf("Up Image thresholding\n"); bytemap_threshold(bin, up_image, UP_FROM, UP_TO); write_bitmap_to_screen(bin, bin, bin); wait_keyhit(); printf("Big blobs greping\n"); bitmap_clear(roi); label_info = label_info_new(); labeling(labelmap, label_info, bin, NEIGHBOR_8); for (label = 0; label < label_info_get_count(label_info); label++) { label_info_glimpse(&area, label, label_info); //printf("area:%d\n", area); if (area > 3000) { for (i = 0; i < h; i++) { for (j = 0; j < w; j++) { if (dwordmap_get_value(labelmap, j, i) == label) { bitmap_set_value(roi, j, i); } } } } } label_info_destroy(label_info); write_bitmap_to_screen(roi, roi, roi); wait_keyhit(); printf("Fill holes\n"); bitmap_complement(bin, roi); labeling_grep_big_blob(roi, bin); bitmap_complement(bin, roi); write_bitmap_to_screen(bin, bin, bin); wait_keyhit(); printf("Image Morphology\n"); binary_closing(tmp, bin, se); binary_opening(up_roi, tmp, se); write_bitmap_to_screen(up_roi, up_roi, up_roi); wait_keyhit(); /////////////////////////////////////// printf("Mid Image thresholding\n"); bytemap_threshold(bin, mid_image, MID_FROM, MID_TO); write_bitmap_to_screen(bin, bin, bin); wait_keyhit(); printf("Big blobs greping\n"); bitmap_clear(roi); label_info = label_info_new(); labeling(labelmap, label_info, bin, NEIGHBOR_8); for (label = 0; label < label_info_get_count(label_info); label++) { label_info_glimpse(&area, label, label_info); //printf("area:%d\n", area); if (area > 3000) { for (i = 0; i < h; i++) { for (j = 0; j < w; j++) { if (dwordmap_get_value(labelmap, j, i) == label) { bitmap_set_value(roi, j, i); } } } } } label_info_destroy(label_info); write_bitmap_to_screen(roi, roi, roi); wait_keyhit(); printf("Fill holes\n"); bitmap_complement(bin, roi); labeling_grep_big_blob(roi, bin); bitmap_complement(bin, roi); write_bitmap_to_screen(bin, bin, bin); wait_keyhit(); printf("Image Morphology\n"); binary_closing(tmp, bin, se); binary_opening(mid_roi, tmp, se); write_bitmap_to_screen(mid_roi, mid_roi, mid_roi); wait_keyhit(); /////////////////////////////////////////////////// printf("Dn Image thresholding\n"); bytemap_threshold(bin, dn_image, DN_FROM, DN_TO); write_bitmap_to_screen(bin, bin, bin); wait_keyhit(); printf("Big blobs greping\n"); bitmap_clear(roi); label_info = label_info_new(); labeling(labelmap, label_info, bin, NEIGHBOR_8); for (label = 0; label < label_info_get_count(label_info); label++) { label_info_glimpse(&area, label, label_info); //printf("area:%d\n", area); if (area > 3000) { for (i = 0; i < h; i++) { for (j = 0; j < w; j++) { if (dwordmap_get_value(labelmap, j, i) == label) { bitmap_set_value(roi, j, i); } } } } } label_info_destroy(label_info); write_bitmap_to_screen(roi, roi, roi); wait_keyhit(); printf("Fill holes\n"); bitmap_complement(bin, roi); labeling_grep_big_blob(roi, bin); bitmap_complement(bin, roi); write_bitmap_to_screen(bin, bin, bin); wait_keyhit(); printf("Image Morphology\n"); binary_closing(tmp, bin, se); binary_opening(dn_roi, tmp, se); write_bitmap_to_screen(dn_roi, dn_roi, dn_roi); wait_keyhit(); /////////////////////////////////////////////// bitmap_clear(roi); bitmap_or(roi, up_roi); bitmap_or(roi, mid_roi); bitmap_or(roi, dn_roi); write_bitmap_to_screen(up_roi, mid_roi, dn_roi); wait_keyhit(); write_bitmap_to_screen(roi, roi, roi); wait_keyhit(); /* //write_bitmap_to_screen(up_roi, mid_roi, dn_roi); //read_bytemap_in_screen(up_image, mid_image, dn_image); strcpy(path, argv[1]); strcat(path, "_up_roi.bmp"); save_bytemap_as_BMP(up_image, path); strcpy(path, argv[1]); strcat(path, "_mid_roi.bmp"); save_bytemap_as_BMP(mid_image, path); strcpy(path, argv[1]); strcat(path, "_dn_roi.bmp"); save_bytemap_as_BMP(dn_image, path); read_bytemap_in_screen(gray, NULL, NULL); strcpy(path, argv[1]); strcat(path, "_roi.bmp"); save_bytemap_as_BMP(gray, path); */ #if 0 // up image statistic ///////////////////////// bytemap_get_min_max_on_roi(&vmin, &vmax, up_image, roi); bytemap_get_mean_on_roi(&vmean, up_image, roi); printf("Up image statistics are min: %d, mean: %lf, max: %d\n", vmin, vmean, vmax); fd = fopen("up_stat.txt", "a+"); fprintf(fd, "%d, %lf, %d\n", vmin, vmean, vmax); fclose(fd); //////////////////////////////////////////////// // mid image statistic ///////////////////////// bytemap_get_min_max_on_roi(&vmin, &vmax, mid_image, roi); bytemap_get_mean_on_roi(&vmean, mid_image, roi); printf("Mid image statistics are min: %d, mean: %lf, max: %d\n", vmin, vmean, vmax); fd = fopen("mid_stat.txt", "a+"); fprintf(fd, "%d, %lf, %d\n", vmin, vmean, vmax); fclose(fd); ///////////////////////////////////////////////// // dn image statistic /////////////////////////// bytemap_get_min_max_on_roi(&vmin, &vmax, dn_image, roi); bytemap_get_mean_on_roi(&vmean, dn_image, roi); printf("Dn image statistics are min: %d, mean: %lf, max: %d\n", vmin, vmean, vmax); fd = fopen("dn_stat.txt", "a+"); fprintf(fd, "%d, %lf, %d\n", vmin, vmean, vmax); fclose(fd); ///////////////////////////////////////////////// return 0; #endif #if 1 // Up image normalization printf("Up-Image global normalization\n"); for (i = 0; i < h; i++) { for (j = 0; j < w; j++) { if (bitmap_isset(roi, j, i)) { value = bytemap_get_value(up_image, j, i); if (value < UP_MEAN) { value = round(128.0 / (UP_MEAN - UP_MIN) * (value - UP_MIN)); } else { value = round(128.0 / (UP_MAX - UP_MEAN) * (value - UP_MEAN) + 128.0); } if (value < 0) value = 0; if (value > 255) value = 255; bytemap_put_value(value, up_image, j, i); } else { bytemap_put_value(0, up_image, j, i); } } } write_bytemap_to_screen(up_image, up_image, up_image); strcpy(path, argv[1]); strcat(path, "_up_normal.bmp"); save_bytemap_as_gray_BMP(up_image, path); wait_keyhit(); ////////////////////////////////////////// // Mid image normalization printf("MID-Image global normalization\n"); for (i = 0; i < h; i++) { for (j = 0; j < w; j++) { if (bitmap_isset(roi, j, i)) { value = bytemap_get_value(mid_image, j, i); if (value < MID_MEAN) { value = round(128.0 / (MID_MEAN - MID_MIN) * (value - MID_MIN)); } else { value = round(128.0 / (MID_MAX - MID_MEAN) * (value - MID_MEAN) + 128.0); } if (value < 0) value = 0; if (value > 255) value = 255; bytemap_put_value(value, mid_image, j, i); } else { bytemap_put_value(0, mid_image, j, i); } } } write_bytemap_to_screen(mid_image, mid_image, mid_image); strcpy(path, argv[1]); strcat(path, "_mid_normal.bmp"); save_bytemap_as_gray_BMP(mid_image, path); wait_keyhit(); /////////////////////////////////////////////// // Dn image normalization printf("Dn image global normalization\n"); for (i = 0; i < h; i++) { for (j = 0; j < w; j++) { if (bitmap_isset(roi, j, i)) { value = bytemap_get_value(dn_image, j, i); if (value < DN_MEAN) { value = round(128.0 / (DN_MEAN - DN_MIN) * (value - DN_MIN)); } else { value = round(128.0 / (DN_MAX - DN_MEAN) * (value - DN_MEAN) + 128.0); } if (value < 0) value = 0; if (value > 255) value = 255; bytemap_put_value(value, dn_image, j, i); } else { bytemap_put_value(0, dn_image, j, i); } } } write_bytemap_to_screen(dn_image, dn_image, dn_image); strcpy(path, argv[1]); strcat(path, "_dn_normal.bmp"); save_bytemap_as_gray_BMP(dn_image, path); wait_keyhit(); //////////////////////////////////////////// return 0; #endif #if 0 printf("Image subtraction between DN and MID for bruise-detection\n"); for (i = 0; i < h; i++) { for (j = 0; j < w; j++) { if (bitmap_isset(roi, j, i)) { value = ((real_t)bytemap_get_value(dn_image, j, i) - (real_t)bytemap_get_value(mid_image, j, i) + 255.0) / 2.0; if (value < 0) value = 0; if (value > 255) value = 255; bytemap_put_value(value, gray, j, i); } else { bytemap_put_value(0, gray, j, i); } } } write_bytemap_to_screen(gray, gray, gray); wait_keyhit(); bytemap_threshold(bin, gray, 142, 255); write_bitmap_to_screen(bin, bin, bin); wait_keyhit(); printf("Image subtraction between UP and MID for spot-detection\n"); for (i = 0; i < h; i++) { for (j = 0; j < w; j++) { if (bitmap_isset(roi, j, i)) { value = ((real_t)bytemap_get_value(up_image, j, i) - (real_t)bytemap_get_value(mid_imageb, j, i) + 255.0) / 2.0; if (value < 0) value = 0; if (value > 255) value = 255; bytemap_put_value(value, gray, j, i); } else { bytemap_put_value(0, gray, j, i); } } } write_bytemap_to_screen(gray, gray, gray); wait_keyhit(); bytemap_threshold(bin, gray, 1, 110); write_bitmap_to_screen(bin, bin, bin); wait_keyhit(); #endif dwordmap_destroy(labelmap); bytemap_destroy(se); return 0; bitmap_destroy(roi); bitmap_destroy(tmp); bitmap_destroy(bin); bitmap_destroy(dn_roi); bitmap_destroy(mid_roi); bitmap_destroy(up_roi); bytemap_destroy(gray); bytemap_destroy(dn_image); bytemap_destroy(mid_image); bytemap_destroy(up_image); return 0; }
static irqreturn_t sh_keysc_isr(int irq, void *dev_id) { struct platform_device *pdev = dev_id; struct sh_keysc_priv *priv = platform_get_drvdata(pdev); struct sh_keysc_info *pdata = &priv->pdata; int keyout_nr = sh_keysc_mode[pdata->mode].keyout; int keyin_nr = sh_keysc_mode[pdata->mode].keyin; DECLARE_BITMAP(keys, SH_KEYSC_MAXKEYS); DECLARE_BITMAP(keys0, SH_KEYSC_MAXKEYS); DECLARE_BITMAP(keys1, SH_KEYSC_MAXKEYS); unsigned char keyin_set, tmp; int i, k, n; dev_dbg(&pdev->dev, "isr!\n"); bitmap_fill(keys1, SH_KEYSC_MAXKEYS); bitmap_zero(keys0, SH_KEYSC_MAXKEYS); do { bitmap_zero(keys, SH_KEYSC_MAXKEYS); keyin_set = 0; sh_keysc_write(priv, KYCR2, KYCR2_IRQ_DISABLED); for (i = 0; i < keyout_nr; i++) { n = keyin_nr * i; /* drive one KEYOUT pin low, read KEYIN pins */ sh_keysc_write(priv, KYOUTDR, 0xffff ^ (3 << (i * 2))); udelay(pdata->delay); tmp = sh_keysc_read(priv, KYINDR); /* set bit if key press has been detected */ for (k = 0; k < keyin_nr; k++) { if (tmp & (1 << k)) __set_bit(n + k, keys); } /* keep track of which KEYIN bits that have been set */ keyin_set |= tmp ^ ((1 << keyin_nr) - 1); } sh_keysc_level_mode(priv, keyin_set); bitmap_complement(keys, keys, SH_KEYSC_MAXKEYS); bitmap_and(keys1, keys1, keys, SH_KEYSC_MAXKEYS); bitmap_or(keys0, keys0, keys, SH_KEYSC_MAXKEYS); sh_keysc_map_dbg(&pdev->dev, keys, "keys"); } while (sh_keysc_read(priv, KYCR2) & 0x01); sh_keysc_map_dbg(&pdev->dev, priv->last_keys, "last_keys"); sh_keysc_map_dbg(&pdev->dev, keys0, "keys0"); sh_keysc_map_dbg(&pdev->dev, keys1, "keys1"); for (i = 0; i < SH_KEYSC_MAXKEYS; i++) { k = pdata->keycodes[i]; if (!k) continue; if (test_bit(i, keys0) == test_bit(i, priv->last_keys)) continue; if (test_bit(i, keys1) || test_bit(i, keys0)) { input_event(priv->input, EV_KEY, k, 1); __set_bit(i, priv->last_keys); } if (!test_bit(i, keys1)) { input_event(priv->input, EV_KEY, k, 0); __clear_bit(i, priv->last_keys); } } input_sync(priv->input); return IRQ_HANDLED; }
void amdgpu_amdkfd_device_init(struct amdgpu_device *adev) { int i, n; int last_valid_bit; if (adev->kfd.dev) { struct kgd2kfd_shared_resources gpu_resources = { .compute_vmid_bitmap = compute_vmid_bitmap, .num_pipe_per_mec = adev->gfx.mec.num_pipe_per_mec, .num_queue_per_pipe = adev->gfx.mec.num_queue_per_pipe, .gpuvm_size = min(adev->vm_manager.max_pfn << AMDGPU_GPU_PAGE_SHIFT, AMDGPU_GMC_HOLE_START), .drm_render_minor = adev->ddev->render->index }; /* this is going to have a few of the MSBs set that we need to * clear */ bitmap_complement(gpu_resources.queue_bitmap, adev->gfx.mec.queue_bitmap, KGD_MAX_QUEUES); /* remove the KIQ bit as well */ if (adev->gfx.kiq.ring.sched.ready) clear_bit(amdgpu_gfx_queue_to_bit(adev, adev->gfx.kiq.ring.me - 1, adev->gfx.kiq.ring.pipe, adev->gfx.kiq.ring.queue), gpu_resources.queue_bitmap); /* According to linux/bitmap.h we shouldn't use bitmap_clear if * nbits is not compile time constant */ last_valid_bit = 1 /* only first MEC can have compute queues */ * adev->gfx.mec.num_pipe_per_mec * adev->gfx.mec.num_queue_per_pipe; for (i = last_valid_bit; i < KGD_MAX_QUEUES; ++i) clear_bit(i, gpu_resources.queue_bitmap); amdgpu_doorbell_get_kfd_info(adev, &gpu_resources.doorbell_physical_address, &gpu_resources.doorbell_aperture_size, &gpu_resources.doorbell_start_offset); if (adev->asic_type < CHIP_VEGA10) { kgd2kfd->device_init(adev->kfd.dev, &gpu_resources); return; } n = (adev->asic_type < CHIP_VEGA20) ? 2 : 8; for (i = 0; i < n; i += 2) { /* On SOC15 the BIF is involved in routing * doorbells using the low 12 bits of the * address. Communicate the assignments to * KFD. KFD uses two doorbell pages per * process in case of 64-bit doorbells so we * can use each doorbell assignment twice. */ gpu_resources.sdma_doorbell[0][i] = adev->doorbell_index.sdma_engine0 + (i >> 1); gpu_resources.sdma_doorbell[0][i+1] = adev->doorbell_index.sdma_engine0 + 0x200 + (i >> 1); gpu_resources.sdma_doorbell[1][i] = adev->doorbell_index.sdma_engine1 + (i >> 1); gpu_resources.sdma_doorbell[1][i+1] = adev->doorbell_index.sdma_engine1 + 0x200 + (i >> 1); } /* Doorbells 0x0e0-0ff and 0x2e0-2ff are reserved for * SDMA, IH and VCN. So don't use them for the CP. */ gpu_resources.reserved_doorbell_mask = 0x1e0; gpu_resources.reserved_doorbell_val = 0x0e0; kgd2kfd->device_init(adev->kfd.dev, &gpu_resources); } } void amdgpu_amdkfd_device_fini(struct amdgpu_device *adev) { if (adev->kfd.dev) { kgd2kfd->device_exit(adev->kfd.dev); adev->kfd.dev = NULL; } } void amdgpu_amdkfd_interrupt(struct amdgpu_device *adev, const void *ih_ring_entry) { if (adev->kfd.dev) kgd2kfd->interrupt(adev->kfd.dev, ih_ring_entry); } void amdgpu_amdkfd_suspend(struct amdgpu_device *adev) { if (adev->kfd.dev) kgd2kfd->suspend(adev->kfd.dev); } int amdgpu_amdkfd_resume(struct amdgpu_device *adev) { int r = 0; if (adev->kfd.dev) r = kgd2kfd->resume(adev->kfd.dev); return r; }