avr/qmk/firmware - [no description]

diff options

author	noroadsleft <18669334+noroadsleft@users.noreply.github.com>	2018-10-01 20:35:09 -0700
committer	Drashna Jaelre <drashna@live.com>	2018-10-01 20:35:09 -0700
commit	abcf64ecbdadc226350d457dfdc5079ce51fd72c (patch)
tree	4bf56d3a893b1f7b5bbcacadedae9158f7a59339 /lib/lufa/Demos/Device/LowLevel/DualVirtualSerial/Config
parent	713ec91147aa56849f9e2ff93ee98ef1eb6eebc0 (diff)
download	firmware-abcf64ecbdadc226350d457dfdc5079ce51fd72c.tar.gz firmware-abcf64ecbdadc226350d457dfdc5079ce51fd72c.tar.bz2 firmware-abcf64ecbdadc226350d457dfdc5079ce51fd72c.zip

Keyboard: DZ60 cleanup (#3994)

* DZ60: Deleted K214 from LAYOUT_all * DZ60: Delete matrix LAYOUT_2_shifts; replace with LAYOUT_all After the deletion of K214 from LAYOUT_all, LAYOUT_all and LAYOUT_2_shifts are identical. Deprecated LAYOUT_2_shifts in favor of LAYOUT_all. * DZ60: refactor 256k_HHKB and itsaferbie keymaps to use LAYOUT_60_hhkb macro Both keymaps previously used the LAYOUT_hhkb macro. After comparing the macros, the only difference between them was that LAYOUT_hhkb included the place of the ISO Backslash key. Neither keymap used this key, so both were refactored to use LAYOUT_60_hhkb instead. LAYOUT_hhkb is now essentially unused by any keymaps in the repo. (More on that in a moment.) * DZ60: bugfix for dbroqua keymap This keymap had two layers that used the LAYOUT_true_hhkb macro and a third that used LAYOUT_hhkb. These macros have the same number of keys, but represent different physical layouts. As the "main" layers used LAYOUT_true_hhkb, switched the third layer to LAYOUT_true_hhkb as well. The LAYOUT_hhkb macro is now unused by any DZ60 keymaps in the repo, and can be safely deleted. * DZ60: bugfix for 60_ansi_arrow_fkeys, 60_plus_arrows, and stephengrier keymaps All three keymaps had one layer in LAYOUT_all and one in LAYOUT_directional. Only difference between these macros is LAYOUT_all excludes the ISO Backslash position. As none of the keymaps used this position, all layers were switched to use LAYOUT_directional. * DZ60: added layout mock-ups to dz60.h Documenting the physical layouts that go with each matrix. * DZ60: replace TMK SHIFT_ESC with QMK Grave Escape Replaced all instances of keycodes that called TMK's ACTION_FUNCTION(SHIFT_ESC) with QMK's KC_GESC, and added config.h files so KC_GESC behaves as the deprecated TMK function did, except for the default keymap, which I thought should have the QMK standard behavior. * DZ60: delete SHIFT_ESC code blocks Deleted ACTION_FUNCTION(SHIFT_ESC) code blocks from keymaps that didn't use the functionality it provided. * DZ60: deleted unused MODS_CTRL_MASk definitions Was used in the now-deleted SHIFT_ESC code blocks. Interestingly named MODS_CTRL_MASK when it was actually checking the Shift keys. *shrug* * DZ60: refactor jkbone keymap to use process_record_user Replaced TMK action_function keycodes with QMK process_record_user equivalents. * DZ60: delete unused layout macros The macros LAYOUT_hhkb, LAYOUT_directional_625_space, and LAYOUT_60_ansi_split_bs_rshift_5x1u were unused by any keymaps in the repo, and have thus been deleted. * DZ60: refactor iso_6u_space and iso_7u_space keymaps Both keymaps refactored to use the LAYOUT_60_iso macro. * DZ60: refactor dz60.h Updated the notation of the switch arguments. Format is now: `k<row><column>` where `<row>` is `[0-4]` and `<column>` is `[0-9a-e]`. * DZ60: refactor LAYOUT_60_iso_5x1u matrix Updated matrix so `KC_ENT` belongs on the home row, which is consistent with LAYOUT_60_iso for the DZ60 as well as the ISO community layouts. * DZ60: fix white space in dz60.h I hate when indentation is inconsistent within a file.

Diffstat (limited to 'lib/lufa/Demos/Device/LowLevel/DualVirtualSerial/Config')

0 files changed, 0 insertions, 0 deletions

/* **************************************************************************** * (C) 2003 - Rolf Neugebauer - Intel Research Cambridge * (C) 2005 - Grzegorz Milos - Intel Research Cambridge **************************************************************************** * * File: mm.c * Author: Rolf Neugebauer (neugebar@dcs.gla.ac.uk) * Changes: Grzegorz Milos * * Date: Aug 2003, chages Aug 2005 * * Environment: Xen Minimal OS * Description: memory management related functions * contains buddy page allocator from Xen. * **************************************************************************** * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to * deal in the Software without restriction, including without limitation the * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ #include <os.h> #include <hypervisor.h> #include <mm.h> #include <types.h> #include <lib.h> #include <xmalloc.h> #ifdef MM_DEBUG #define DEBUG(_f, _a...) \ printk("MINI_OS(file=mm.c, line=%d) " _f "\n", __LINE__, ## _a) #else #define DEBUG(_f, _a...) ((void)0) #endif unsigned long *phys_to_machine_mapping; extern char *stack; extern char _text, _etext, _edata, _end; /********************* * ALLOCATION BITMAP * One bit per page of memory. Bit set => page is allocated. */ static unsigned long *alloc_bitmap; #define PAGES_PER_MAPWORD (sizeof(unsigned long) * 8) #define allocated_in_map(_pn) \ (alloc_bitmap[(_pn)/PAGES_PER_MAPWORD] & (1<<((_pn)&(PAGES_PER_MAPWORD-1)))) /* * Hint regarding bitwise arithmetic in map_{alloc,free}: * -(1<<n) sets all bits >= n. * (1<<n)-1 sets all bits < n. * Variable names in map_{alloc,free}: * *_idx == Index into `alloc_bitmap' array. * *_off == Bit offset within an element of the `alloc_bitmap' array. */ static void map_alloc(unsigned long first_page, unsigned long nr_pages) { unsigned long start_off, end_off, curr_idx, end_idx; curr_idx = first_page / PAGES_PER_MAPWORD; start_off = first_page & (PAGES_PER_MAPWORD-1); end_idx = (first_page + nr_pages) / PAGES_PER_MAPWORD; end_off = (first_page + nr_pages) & (PAGES_PER_MAPWORD-1); if ( curr_idx == end_idx ) { alloc_bitmap[curr_idx] |= ((1<<end_off)-1) & -(1<<start_off); } else { alloc_bitmap[curr_idx] |= -(1<<start_off); while ( ++curr_idx < end_idx ) alloc_bitmap[curr_idx] = ~0L; alloc_bitmap[curr_idx] |= (1<<end_off)-1; } } static void map_free(unsigned long first_page, unsigned long nr_pages) { unsigned long start_off, end_off, curr_idx, end_idx; curr_idx = first_page / PAGES_PER_MAPWORD; start_off = first_page & (PAGES_PER_MAPWORD-1); end_idx = (first_page + nr_pages) / PAGES_PER_MAPWORD; end_off = (first_page + nr_pages) & (PAGES_PER_MAPWORD-1); if ( curr_idx == end_idx ) { alloc_bitmap[curr_idx] &= -(1<<end_off) | ((1<<start_off)-1); } else { alloc_bitmap[curr_idx] &= (1<<start_off)-1; while ( ++curr_idx != end_idx ) alloc_bitmap[curr_idx] = 0; alloc_bitmap[curr_idx] &= -(1<<end_off); } } /************************* * BINARY BUDDY ALLOCATOR */ typedef struct chunk_head_st chunk_head_t; typedef struct chunk_tail_st chunk_tail_t; struct chunk_head_st { chunk_head_t *next; chunk_head_t **pprev; int level; }; struct chunk_tail_st { int level; }; /* Linked lists of free chunks of different powers-of-two in size. */ #define FREELIST_SIZE ((sizeof(void*)<<3)-PAGE_SHIFT) static chunk_head_t *free_head[FREELIST_SIZE]; static chunk_head_t free_tail[FREELIST_SIZE]; #define FREELIST_EMPTY(_l) ((_l)->next == NULL) #define round_pgdown(_p) ((_p)&PAGE_MASK) #define round_pgup(_p) (((_p)+(PAGE_SIZE-1))&PAGE_MASK) #ifdef MM_DEBUG /* * Prints allocation[0/1] for @nr_pages, starting at @start * address (virtual). */ static void print_allocation(void *start, int nr_pages) { unsigned long pfn_start = virt_to_pfn(start); int count; for(count = 0; count < nr_pages; count++) if(allocated_in_map(pfn_start + count)) printk("1"); else printk("0"); printk("\n"); } /* * Prints chunks (making them with letters) for @nr_pages starting * at @start (virtual). */ static void print_chunks(void *start, int nr_pages) { char chunks[1001], current='A'; int order, count; chunk_head_t *head; unsigned long pfn_start = virt_to_pfn(start); memset(chunks, (int)'_', 1000); if(nr_pages > 1000) { DEBUG("Can only pring 1000 pages. Increase buffer size."); } for(order=0; order < FREELIST_SIZE; order++) { head = free_head[order]; while(!FREELIST_EMPTY(head)) { for(count = 0; count < 1<< head->level; count++) { if(count + virt_to_pfn(head) - pfn_start < 1000) chunks[count + virt_to_pfn(head) - pfn_start] = current; } head = head->next; current++; } } chunks[nr_pages] = '\0'; printk("%s\n", chunks); } #endif /* * Initialise allocator, placing addresses [@min,@max] in free pool. * @min and @max are PHYSICAL addresses. */ static void init_page_allocator(unsigned long min, unsigned long max) { int i; unsigned long range, bitmap_size; chunk_head_t *ch; chunk_tail_t *ct; for ( i = 0; i < FREELIST_SIZE; i++ ) { free_head[i] = &free_tail[i]; free_tail[i].pprev = &free_head[i]; free_tail[i].next = NULL; } min = round_pgup (min); max = round_pgdown(max); /* Allocate space for the allocation bitmap. */ bitmap_size = (max+1) >> (PAGE_SHIFT+3); bitmap_size = round_pgup(bitmap_size); alloc_bitmap = (unsigned long *)to_virt(min); min += bitmap_size; range = max - min; /* All allocated by default. */ memset(alloc_bitmap, ~0, bitmap_size); /* Free up the memory we've been given to play with. */ map_free(min>>PAGE_SHIFT, range>>PAGE_SHIFT); /* The buddy lists are addressed in high memory. */ min += VIRT_START; max += VIRT_START; while ( range != 0 ) { /* * Next chunk is limited by alignment of min, but also * must not be bigger than remaining range. */ for ( i = PAGE_SHIFT; (1<<(i+1)) <= range; i++ ) if ( min & (1<<i) ) break; ch = (chunk_head_t *)min; min += (1<<i); range -= (1<<i);


context:
space:
mode: