# "atmega32u4" # Teensy 2.0 (avr)
# "at90usb646" # Teensy++ 1.0 (avr)
# "at90usb1286" # Teensy++ 2.0 (avr)
-# "mk20dx128" # Teensy 3.0 (arm)
- "mk20dx128vlf5" # McHCK mk20dx128vlf5
+ "mk20dx128" # Teensy 3.0 (arm)
+# "mk20dx128vlf5" # McHCK mk20dx128vlf5
# "mk20dx256" # Teensy 3.1 (arm)
)
set( MacroModule "PartialMap" )
##| Sends the current list of usb key codes through USB HID
-set( OutputModule "pjrcUSB" )
+set( OutputModule "uartOut" )
##| Debugging source to use, each module has it's own set of defines that it sets
set( DebugModule "full" )
}
-
void usb_device_reload()
{
asm volatile("bkpt");
}
-void _reboot_Teensyduino_(void)
-{
- // TODO: initialize R0 with a code....
- asm volatile("bkpt");
-}
-
-
-
void usb_isr(void)
{
uint8_t status, stat, t;
t = usb_reboot_timer;
if (t) {
usb_reboot_timer = --t;
- if (!t) _reboot_Teensyduino_();
+ if (!t) usb_device_reload();
}
#ifdef CDC_DATA_INTERFACE
t = usb_cdc_transmit_flush_timer;
// If the Teensy is powered without a PC connected to the USB port,
// this will wait forever.
usb_init();
+#include <led.h>
+init_errorLED();
+errorLED( 1 );
+while(1);
while ( !usb_configured() ) /* wait */ ;
// Register USB Output CLI dictionary
// USB Data Send
inline void Output_send(void)
{
- // TODO undo potentially old keys
- for ( uint8_t c = USBKeys_Sent; c < USBKeys_MaxSize; c++ )
- USBKeys_Array[c] = 0;
+ // TODO undo potentially old keys
+ for ( uint8_t c = USBKeys_Sent; c < USBKeys_MaxSize; c++ )
+ USBKeys_Array[c] = 0;
- // Send keypresses
- usb_keyboard_send();
+ // Send keypresses
+ usb_keyboard_send();
- // Clear modifiers and keys
- USBKeys_Modifiers = 0;
- USBKeys_Sent = 0;
+ // Clear modifiers and keys
+ USBKeys_Modifiers = 0;
+ USBKeys_Sent = 0;
- // Signal Scan Module we are finishedA
- Scan_finishedWithUSBBuffer( USBKeys_Sent <= USBKeys_MaxSize ? USBKeys_Sent : USBKeys_MaxSize );
+ // Signal Scan Module we are finishedA
+ Scan_finishedWithUSBBuffer( USBKeys_Sent <= USBKeys_MaxSize ? USBKeys_Sent : USBKeys_MaxSize );
}
--- /dev/null
+/* Copyright (C) 2014 by Jacob Alexander
+ *
+ * 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 "uart_serial.h"
+#include <Lib/OutputLib.h>
+#include <Lib/Interrupts.h>
+#include <string.h> // For memcpy
+
+// ----- Variables -----
+
+#define uart0_buffer_size 32 // 32 byte buffer
+volatile uint8_t uart0_buffer_head = 0;
+volatile uint8_t uart0_buffer_tail = 0;
+volatile uint8_t uart0_buffer_items = 0;
+volatile uint8_t uart0_buffer[uart0_buffer_size];
+
+
+// ----- Interrupt Functions -----
+
+void uart0_status_isr()
+{
+ cli(); // Disable Interrupts
+
+ // UART0_S1 must be read for the interrupt to be cleared
+ if ( UART0_S1 & UART_S1_RDRF )
+ {
+ // Read UART0 into buffer until FIFO is empty
+ while ( !( UART0_SFIFO & UART_SFIFO_RXEMPT ) )
+ {
+ uart0_buffer[uart0_buffer_tail++] = UART0_D;
+ uart0_buffer_items++;
+
+ // Wrap-around of tail pointer
+ if ( uart0_buffer_tail >= uart0_buffer_size )
+ {
+ uart0_buffer_tail = 0;
+ }
+
+ // Make sure the head pointer also moves if circular buffer is overwritten
+ if ( uart0_buffer_head == uart0_buffer_tail )
+ {
+ uart0_buffer_head++;
+ }
+
+ // Wrap-around of head pointer
+ if ( uart0_buffer_head >= uart0_buffer_size )
+ {
+ uart0_buffer_head = 0;
+ }
+
+ }
+ }
+
+ sei(); // Re-enable Interrupts
+}
+
+
+// ----- Functions -----
+
+void uart_serial_setup()
+{
+ // Setup the the UART interface for keyboard data input
+ SIM_SCGC4 |= SIM_SCGC4_UART0; // Disable clock gating
+
+ // Pin Setup for UART0
+ PORTB_PCR16 = PORT_PCR_PE | PORT_PCR_PS | PORT_PCR_PFE | PORT_PCR_MUX(3); // RX Pin
+ PORTB_PCR17 = PORT_PCR_DSE | PORT_PCR_SRE | PORT_PCR_MUX(3); // TX Pin
+
+ // Setup baud rate - 9600 Baud
+ // 48 MHz / ( 16 * Baud ) = BDH/L
+ // Baud: 9600 -> 48 MHz / ( 16 * 9600 ) = 312.5
+ // Thus baud setting = 313
+ // NOTE: If finer baud adjustment is needed see UARTx_C4 -> BRFA in the datasheet
+ uint16_t baud = 313; // Max setting of 8191
+ UART0_BDH = (uint8_t)(baud >> 8);
+ UART0_BDL = (uint8_t)baud;
+
+ // 8 bit, No Parity, Idle Character bit after stop
+ UART0_C1 = UART_C1_ILT;
+
+ // TX FIFO Disabled, TX FIFO Size 1 (Max 8 datawords), RX FIFO Enabled, RX FIFO Size 1 (Max 8 datawords)
+ // TX/RX FIFO Size:
+ // 0x0 - 1 dataword
+ // 0x1 - 4 dataword
+ // 0x2 - 8 dataword
+ UART0_PFIFO = UART_PFIFO_TXFE | UART_PFIFO_RXFE;
+
+ // Reciever Inversion Disabled, LSBF
+ // UART_S2_RXINV UART_S2_MSBF
+ UART0_S2 |= 0x00;
+
+ // Transmit Inversion Disabled
+ // UART_C3_TXINV
+ UART0_C3 |= 0x00;
+
+ // TX Disabled, RX Enabled, RX Interrupt Enabled
+ // UART_C2_TE UART_C2_RE UART_C2_RIE
+ UART0_C2 = UART_C2_TE | UART_C2_RE | UART_C2_RIE;
+
+ // Add interrupt to the vector table
+ NVIC_ENABLE_IRQ( IRQ_UART0_STATUS );
+}
+
+
+// Get the next character, or -1 if nothing received
+int uart_serial_getchar()
+{
+ unsigned int value = -1;
+
+ // Check to see if the FIFO has characters
+ if ( uart0_buffer_items > 0 )
+ {
+ value = uart0_buffer[uart0_buffer_head++];
+ uart0_buffer_items--;
+
+ // Wrap-around of head pointer
+ if ( uart0_buffer_head >= uart0_buffer_size )
+ {
+ uart0_buffer_head = 0;
+ }
+ }
+
+ return value;
+}
+
+
+// Number of bytes available in the receive buffer
+int uart_serial_available()
+{
+ return uart0_buffer_items;
+}
+
+
+// Discard any buffered input
+void uart_serial_flush_input()
+{
+ uart0_buffer_head = 0;
+ uart0_buffer_tail = 0;
+ uart0_buffer_items = 0;
+}
+
+
+// Transmit a character. 0 returned on success, -1 on error
+int uart_serial_putchar( uint8_t c )
+{
+ return uart_serial_write( &c, 1 );
+}
+
+
+int uart_serial_write( const void *buffer, uint32_t size )
+{
+ const uint8_t *data = (const uint8_t *)buffer;
+ uint32_t position = 0;
+
+ // While buffer is not empty and transmit buffer is
+ while ( position < size )
+ {
+ while ( !( UART0_SFIFO & UART_SFIFO_TXEMPT ) ); // Wait till there is room to send
+ UART0_D = data[position++];
+ }
+
+ return 0;
+}
+
+
+void uart_serial_flush_output()
+{
+ // Delay until buffer has been sent
+ while ( !( UART0_SFIFO & UART_SFIFO_TXEMPT ) ); // Wait till there is room to send
+}
+
+
+void uart_device_reload()
+{
+ asm volatile("bkpt");
+}
+
--- /dev/null
+/* Copyright (C) 2014 by Jacob Alexander
+ *
+ * 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.
+ */
+
+#ifndef __uart_serial_h_
+#define __uart_serial_h_
+
+#include <inttypes.h>
+
+int uart_serial_getchar();
+int uart_serial_available();
+int uart_serial_putchar( uint8_t c );
+int uart_serial_write( const void *buffer, uint32_t size );
+
+void uart_serial_flush_input();
+void uart_serial_flush_output();
+
+void uart_serial_setup();
+
+void uart_device_reload();
+
+#endif // __uart_serial_h_
+
--- /dev/null
+/* Copyright (C) 2014 by Jacob Alexander
+ *
+ * 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.
+ */
+
+// ----- Includes -----
+
+// Compiler Includes
+#include <Lib/OutputLib.h>
+
+// Project Includes
+#include <cli.h>
+#include <print.h>
+#include <scan_loop.h>
+
+// USB Includes
+#if defined(_at90usb162_) || defined(_atmega32u4_) || defined(_at90usb646_) || defined(_at90usb1286_)
+#include "avr/uart_serial.h"
+#elif defined(_mk20dx128_) || defined(_mk20dx128vlf5_) || defined(_mk20dx256_)
+#include "arm/uart_serial.h"
+#endif
+
+// Local Includes
+#include "output_com.h"
+
+
+
+// ----- Function Declarations -----
+
+void cliFunc_kbdProtocol( char* args );
+void cliFunc_readLEDs ( char* args );
+void cliFunc_sendKeys ( char* args );
+void cliFunc_setKeys ( char* args );
+void cliFunc_setMod ( char* args );
+
+
+// ----- Variables -----
+
+// Output Module command dictionary
+char* outputCLIDictName = "USB Module Commands - NOT WORKING";
+CLIDictItem outputCLIDict[] = {
+ { "kbdProtocol", "Keyboard Protocol Mode: 0 - Boot, 1 - OS/NKRO Mode", cliFunc_kbdProtocol },
+ { "readLEDs", "Read LED byte:" NL "\t\t1 NumLck, 2 CapsLck, 4 ScrlLck, 16 Kana, etc.", cliFunc_readLEDs },
+ { "sendKeys", "Send the prepared list of USB codes and modifier byte.", cliFunc_sendKeys },
+ { "setKeys", "Prepare a space separated list of USB codes (decimal). Waits until \033[35msendKeys\033[0m.", cliFunc_setKeys },
+ { "setMod", "Set the modfier byte:" NL "\t\t1 LCtrl, 2 LShft, 4 LAlt, 8 LGUI, 16 RCtrl, 32 RShft, 64 RAlt, 128 RGUI", cliFunc_setMod },
+ { 0, 0, 0 } // Null entry for dictionary end
+};
+
+
+// Which modifier keys are currently pressed
+// 1=left ctrl, 2=left shift, 4=left alt, 8=left gui
+// 16=right ctrl, 32=right shift, 64=right alt, 128=right gui
+ uint8_t USBKeys_Modifiers = 0;
+ uint8_t USBKeys_ModifiersCLI = 0; // Separate CLI send buffer
+
+// Currently pressed keys, max is defined by USB_MAX_KEY_SEND
+ uint8_t USBKeys_Array [USB_MAX_KEY_SEND];
+ uint8_t USBKeys_ArrayCLI[USB_MAX_KEY_SEND]; // Separate CLI send buffer
+
+// The number of keys sent to the usb in the array
+ uint8_t USBKeys_Sent = 0;
+ uint8_t USBKeys_SentCLI = 0;
+
+// 1=num lock, 2=caps lock, 4=scroll lock, 8=compose, 16=kana
+volatile uint8_t USBKeys_LEDs = 0;
+
+// Protocol setting from the host.
+// 0 - Boot Mode (Default, until set by the host)
+// 1 - NKRO Mode
+volatile uint8_t USBKeys_Protocol = 1;
+
+// the idle configuration, how often we send the report to the
+// host (ms * 4) even when it hasn't changed
+ uint8_t USBKeys_Idle_Config = 125;
+
+// count until idle timeout
+ uint8_t USBKeys_Idle_Count = 0;
+
+
+// ----- Functions -----
+
+// USB Module Setup
+inline void Output_setup()
+{
+ // Setup UART
+ uart_serial_setup();
+
+ // Register USB Output CLI dictionary
+ CLI_registerDictionary( outputCLIDict, outputCLIDictName );
+}
+
+
+// USB Data Send
+inline void Output_send(void)
+{
+ // TODO
+}
+
+
+// Sets the device into firmware reload mode
+inline void Output_firmwareReload()
+{
+#if defined(_at90usb162_) || defined(_atmega32u4_) || defined(_at90usb646_) || defined(_at90usb1286_)
+ uart_debug_reload();
+#elif defined(_mk20dx128_) || defined(_mk20dx128vlf5_) || defined(_mk20dx256_)
+ uart_device_reload();
+#endif
+}
+
+
+// USB Input buffer available
+inline unsigned int Output_availablechar()
+{
+ return uart_serial_available();
+}
+
+
+// USB Get Character from input buffer
+inline int Output_getchar()
+{
+#if defined(_at90usb162_) || defined(_atmega32u4_) || defined(_at90usb646_) || defined(_at90usb1286_)
+ // XXX Make sure to check output_availablechar() first! Information is lost with the cast (error codes)
+ return (int)uart_serial_getchar();
+#elif defined(_mk20dx128_) || defined(_mk20dx128vlf5_) || defined(_mk20dx256_)
+ return uart_serial_getchar();
+#endif
+}
+
+
+// USB Send Character to output buffer
+inline int Output_putchar( char c )
+{
+ return uart_serial_putchar( c );
+}
+
+
+// USB Send String to output buffer, null terminated
+inline int Output_putstr( char* str )
+{
+#if defined(_at90usb162_) || defined(_atmega32u4_) || defined(_at90usb646_) || defined(_at90usb1286_) // AVR
+ uint16_t count = 0;
+#elif defined(_mk20dx128_) || defined(_mk20dx128vlf5_) || defined(_mk20dx256_) // ARM
+ uint32_t count = 0;
+#endif
+ // Count characters until NULL character, then send the amount counted
+ while ( str[count] != '\0' )
+ count++;
+
+ return uart_serial_write( str, count );
+}
+
+
+// Soft Chip Reset
+inline void Output_softReset()
+{
+#if defined(_at90usb162_) || defined(_atmega32u4_) || defined(_at90usb646_) || defined(_at90usb1286_)
+ uart_debug_software_reset();
+#elif defined(_mk20dx128_) || defined(_mk20dx128vlf5_) || defined(_mk20dx256_)
+ SOFTWARE_RESET();
+#endif
+}
+
+
+// ----- CLI Command Functions -----
+
+void cliFunc_kbdProtocol( char* args )
+{
+ print( NL );
+ info_msg("Keyboard Protocol: ");
+ printInt8( USBKeys_Protocol );
+}
+
+
+void cliFunc_readLEDs( char* args )
+{
+ print( NL );
+ info_msg("LED State (This doesn't work yet...): ");
+ printInt8( USBKeys_LEDs );
+}
+
+
+void cliFunc_sendKeys( char* args )
+{
+ // Copy USBKeys_ArrayCLI to USBKeys_Array
+ for ( uint8_t key = 0; key < USBKeys_SentCLI; ++key )
+ {
+ USBKeys_Array[key] = USBKeys_ArrayCLI[key];
+ }
+ USBKeys_Sent = USBKeys_SentCLI;
+
+ // Set modifier byte
+ USBKeys_Modifiers = USBKeys_ModifiersCLI;
+}
+
+
+void cliFunc_setKeys( char* args )
+{
+ char* curArgs;
+ char* arg1Ptr;
+ char* arg2Ptr = args;
+
+ // Parse up to USBKeys_MaxSize args (whichever is least)
+ for ( USBKeys_SentCLI = 0; USBKeys_SentCLI < USBKeys_MaxSize; ++USBKeys_SentCLI )
+ {
+ curArgs = arg2Ptr;
+ CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
+
+ // Stop processing args if no more are found
+ if ( *arg1Ptr == '\0' )
+ break;
+
+ // Add the USB code to be sent
+ USBKeys_ArrayCLI[USBKeys_SentCLI] = decToInt( arg1Ptr );
+ }
+}
+
+
+void cliFunc_setMod( char* args )
+{
+ // Parse number from argument
+ // NOTE: Only first argument is used
+ char* arg1Ptr;
+ char* arg2Ptr;
+ CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr );
+
+ USBKeys_ModifiersCLI = decToInt( arg1Ptr );
+}
+
--- /dev/null
+/* Copyright (C) 2013-2014 by Jacob Alexander
+ *
+ * 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.
+ */
+
+#ifndef __output_com_h
+#define __output_com_h
+
+// ----- Includes -----
+
+// Compiler Includes
+#include <stdint.h>
+
+// Local Includes
+#include <buildvars.h> // Defines USB Parameters, partially generated by CMake
+
+
+
+// ----- Defines -----
+
+// Indicator for other modules through USBKeys_MaxSize for how capable the USB module is when sending large number of keypresses
+#define USB_MAX_KEY_SEND 6
+
+
+
+// ----- Variables -----
+
+// Variables used to communciate to the output module
+// XXX Even if the output module is not USB, this is internally understood keymapping scheme
+extern uint8_t USBKeys_Modifiers;
+extern uint8_t USBKeys_Array[USB_MAX_KEY_SEND];
+extern uint8_t USBKeys_Sent;
+extern volatile uint8_t USBKeys_LEDs;
+
+ static const uint8_t USBKeys_MaxSize = USB_MAX_KEY_SEND;
+extern volatile uint8_t USBKeys_Protocol; // 0 - Boot Mode, 1 - NKRO Mode
+
+// Misc variables (XXX Some are only properly utilized using AVR)
+extern uint8_t USBKeys_Idle_Config;
+extern uint8_t USBKeys_Idle_Count;
+
+
+
+// ----- Functions -----
+
+void Output_setup();
+void Output_send();
+
+void Output_firmwareReload();
+void Output_softReset();
+
+// Relies on USB serial module
+unsigned int Output_availablechar();
+
+int Output_getchar();
+int Output_putchar( char c );
+int Output_putstr( char* str );
+
+#endif
+
--- /dev/null
+###| CMake Kiibohd Controller UART Output Module |###
+#
+# Written by Jacob Alexander in 2014 for the Kiibohd Controller
+#
+# Released into the Public Domain
+#
+###
+
+
+###
+# Module C files
+#
+
+
+#| AVR Compiler
+if ( ${COMPILER_FAMILY} MATCHES "avr" )
+
+ set( OUTPUT_SRCS
+ output_com.c
+ avr/uart_serial.c
+ )
+
+#| ARM Compiler
+elseif ( ${COMPILER_FAMILY} MATCHES "arm" )
+
+ set( OUTPUT_SRCS
+ output_com.c
+ arm/uart_serial.c
+ )
+
+endif ()
+
+
+###
+# Module Specific Options
+#
+
+###
+# Compiler Family Compatibility
+#
+set( OutputModuleCompatibility
+ arm
+# avr # TODO
+)
+
projects / kiibohd-controller.git / commitdiff