LCOM1920-T02G10

{

  "env": {

    "minix.include": "${workspaceFolder}/../.minix-src/include"

  },

  "configurations": [{

    "name": "Minix",

    "compilerPath": "",

    "cStandard": "c11",

    "defines": ["__minix", "_MINIX ", "_NETBSD_SOURCE", "__i386__"],

    "includePath": ["${workspaceFolder}", "${env:minix.include}"],

    "browse": {

      "path": ["${workspaceFolder}", "${env:minix.include}"],

      "limitSymbolsToIncludedHeaders": false,

      "databaseFilename": ""

    }

  }],

  "version": 4

}

{

	// See http://go.microsoft.com/fwlink/?LinkId=827846 to learn about workspace recommendations.

	// Extension identifier format: ${publisher}.${name}. Example: vscode.csharp

	// List of extensions which should be recommended for users of this workspace.

	"recommendations": [

		"austin.code-gnu-global",

		"ms-vscode.cpptools",

		"xaver.clang-format"

	],

	// List of extensions recommended by VS Code that should not be recommended for users of this workspace.

	"unwantedRecommendations": []

}

{

  "git.ignoreLimitWarning": true,

  "C_Cpp.clang_format_fallbackStyle": "LLVM",

  "diffEditor.ignoreTrimWhitespace": true,

  "editor.formatOnSave": false,

  "editor.tabSize": 2,

  "editor.wordWrap": "bounded",

  "editor.wordWrapColumn": 100,

  "files.associations": { },

}

BasedOnStyle: LLVM

AccessModifierOffset: -2

AlignAfterOpenBracket: true

AlignEscapedNewlinesLeft: false

AlignOperands: true

AlignTrailingComments: true

AllowAllParametersOfDeclarationOnNextLine: true

AllowShortBlocksOnASingleLine: true

AllowShortCaseLabelsOnASingleLine: true

AllowShortFunctionsOnASingleLine: All

AllowShortIfStatementsOnASingleLine: false

AllowShortLoopsOnASingleLine: true

AlwaysBreakAfterDefinitionReturnType: false

AlwaysBreakBeforeMultilineStrings: false

AlwaysBreakTemplateDeclarations: false

BinPackArguments: true

BinPackParameters: true

BraceWrapping:

  AfterClass:      false

  AfterControlStatement: false

  AfterEnum:       false

  AfterFunction:   false

  AfterNamespace:  false

  AfterObjCDeclaration: true

  AfterStruct:     false

  AfterUnion:      false

  BeforeCatch:     true

  BeforeElse:      true

  IndentBraces:    false

BreakBeforeBinaryOperators: None

BreakBeforeBraces: Custom

BreakBeforeTernaryOperators: true

BreakConstructorInitializersBeforeComma: false

ColumnLimit: 0

CommentPragmas: '^ IWYU pragma:'

ConstructorInitializerAllOnOneLineOrOnePerLine: false

ConstructorInitializerIndentWidth: 2

ContinuationIndentWidth: 2

Cpp11BracedListStyle: true

DerivePointerAlignment: false

DisableFormat: false

ExperimentalAutoDetectBinPacking: false

IndentCaseLabels: true

IndentPPDirectives: AfterHash

IndentWidth: 2

IndentWrappedFunctionNames: false

KeepEmptyLinesAtTheStartOfBlocks: true

Language: Cpp

MaxEmptyLinesToKeep: 1

NamespaceIndentation: None

ObjCBlockIndentWidth: 2

ObjCSpaceAfterProperty: false

ObjCSpaceBeforeProtocolList: true

PenaltyBreakBeforeFirstCallParameter: 19

PenaltyBreakComment: 300

PenaltyBreakFirstLessLess: 120

PenaltyBreakString: 1000

PenaltyExcessCharacter: 1000000

PenaltyReturnTypeOnItsOwnLine: 60

PointerAlignment: Right

SpaceAfterCStyleCast: true

SpaceBeforeAssignmentOperators: true

SpaceBeforeParens: ControlStatements

SpaceInEmptyParentheses: false

SpacesBeforeTrailingComments: 1

SpacesInAngles: false

SpacesInCStyleCastParentheses: false

SpacesInContainerLiterals: true

SpacesInParentheses: false

SpacesInSquareBrackets: false

Standard: Cpp11

TabWidth: 2

UseTab: Never

# name of the program (Minix service)

PROG=lab3

# source code files to be compiled

SRCS = lab3.c 

# additional compilation flags

# "-Wall -Wextra -Werror -I . -std=c11 -Wno-unused-parameter" are already set

CFLAGS += -pedantic

# list of library dependencies (for Lab 2, only LCF library)

DPADD += ${LIBLCF}

LDADD += -llcf

# include LCOM's makefile that does all the "heavy lifting"

.include <minix.lcom.mk>

#ifndef _LCOM_I8254_H_

#define _LCOM_I8254_H_

#include <lcom/lcf.h>

/** @defgroup i8254 i8254

 * @{

 *

 * Constants for programming the i8254 Timer. Needs to be completed.

 */

/*IRQ's*/

#define IRQ_TIMER 0

#define DEFAULT_FREQ 60

#define TIMER_FREQ 1193182 /**< @brief clock frequency for timer in PC and AT */

#define MIN_FREQ 19

#define TIMER0_IRQ 0 /**< @brief Timer 0 IRQ line */

/* I/O port addresses */

#define TIMER_0    0x40 /**< @brief Timer 0 count register */

#define TIMER_1    0x41 /**< @brief Timer 1 count register */

#define TIMER_2    0x42 /**< @brief Timer 2 count register */

#define TIMER_CTRL 0x43 /**< @brief Control register */

#define SPEAKER_CTRL 0x61 /**< @brief Register for speaker control  */

/* Timer control */

/* Timer selection: bits 7 and 6 */

#define TIMER_SEL0   0x00              /**< @brief Control Word for Timer 0 */

#define TIMER_SEL1   BIT(6)            /**< @brief Control Word for Timer 1 */

#define TIMER_SEL2   BIT(7)            /**< @brief Control Word for Timer 2 */

#define TIMER_RB_CMD (BIT(7) | BIT(6)) /**< @brief Read Back Command */

/* Register selection: bits 5 and 4 */

#define TIMER_LSB     BIT(4)                  /**< @brief Initialize Counter LSB only */

#define TIMER_MSB     BIT(5)                  /**< @brief Initialize Counter MSB only */

#define TIMER_LSB_MSB (TIMER_LSB | TIMER_MSB) /**< @brief Initialize LSB first and MSB afterwards */

/* Operating mode: bits 3, 2 and 1 */

#define TIMER_SQR_WAVE (BIT(2) | BIT(1)) /**< @brief Mode 3: square wave generator */

#define TIMER_RATE_GEN BIT(2)            /**< @brief Mode 2: rate generator */

/* Counting mode: bit 0 */

#define TIMER_BCD 0x01 /**< @brief Count in BCD */

#define TIMER_BIN 0x00 /**< @brief Count in binary */

/* READ-BACK COMMAND FORMAT */

#define TIMER_RB_COUNT_  BIT(5)

#define TIMER_RB_STATUS_ BIT(4)

#define TIMER_RB_SEL(n)  BIT((n) + 1)

/**@}*/

#endif /* _LCOM_I8254_H */

#include <lcom/lcf.h>

#include <lcom/lab2.h>

#include <stdbool.h>

#include <stdint.h>

#include "i8254.h"

//#include "timer.c"

extern uint32_t cont;

int main(int argc, char *argv[]) {

  // sets the language of LCF messages (can be either EN-US or PT-PT)

  lcf_set_language("EN-US");

  // enables to log function invocations that are being "wrapped" by LCF

  // [comment this out if you don't want/need it]

  lcf_trace_calls("/home/lcom/labs/lab2/trace.txt");

  // enables to save the output of printf function calls on a file

  // [comment this out if you don't want/need it]

  lcf_log_output("/home/lcom/labs/lab2/output.txt");

  // handles control over to LCF

  // [LCF handles command line arguments and invokes the right function]

  if (lcf_start(argc, argv))

    return 1;

  // LCF clean up tasks

  // [must be the last statement before return]

  lcf_cleanup();

  return 0;

}

int(timer_test_read_config)(uint8_t timer, enum timer_status_field field) {

  /* To be implemented by the students */

  uint8_t st;

  if(timer_get_conf(timer,&st)==1) return 1;

  if(timer_display_conf(timer,st,field)==1) return 1;

  return 0;

 // printf("%s is not yet implemented!\n", __func__);

}

int(timer_test_time_base)(uint8_t timer, uint32_t freq) {

  /* To be implemented by the students */

  if(freq<MIN_FREQ || freq>TIMER_FREQ)

  {

    printf("OUT OF RANGE FREQUENCY\n");

    return 1;

  }

  return(timer_set_frequency(timer,freq));

  //printf("%s is not yet implemented!\n", __func__);

}

int(timer_test_int)(uint8_t time) {

  /* To be implemented by the students */

  if(time<0) 

  {

    printf("INVALID TIME!");

  return 1;

  }

  int ipc_status;

  message msg;

  uint8_t r;

  uint8_t bit_no = 0;

  timer_subscribe_int(&bit_no);

  while( (cont/DEFAULT_FREQ)<time )

 { /* You may want to use a different condition */

     /* Get a request message. */

     // printf("1\n");

     //printf("cont:%d, time:%d\n\n",cont/60,time);

     if ( (r = driver_receive(ANY, &msg, &ipc_status)) != 0 ) 

     { 

        printf("driver_receive failed with: %d", r);

       continue;

    }

    if (is_ipc_notify(ipc_status)) { /* received notification */

        switch (_ENDPOINT_P(msg.m_source)) {

            case HARDWARE: /* hardware interrupt notification */				

                if (msg.m_notify.interrupts  & BIT(0)) { /* subscribed interrupt */

                   timer_int_handler();

                   if(cont%DEFAULT_FREQ==0)

                   timer_print_elapsed_time();

                   //printf("cont:%d\n",cont);

               }

                //printf("msg:%x\n",msg.m_notify.interrupts);

                break;

            default:

                //printf("2\n");

                break; /* no other notifications expected: do nothing */	

        }

    } else {

     // printf("3\n"); /* received a standard message, not a notification */

        /* no standard messages expected: do nothing */

    }

 }

 if(timer_unsubscribe_int()!=0) return 1;

  //printf("%s is not yet implemented!\n", __func__);

  return 0;

}

//dois primeiros bits sao 1, (TIMER_RB_CNTRL|BIT(5))

//SYS_OUTB para controlo->0x43, Config timer 0, dizer que queremos escrever para o controlo, e depois ler a parte corresponder

//g9

#include <lcom/lcf.h>

#include <minix/sysutil.h>

#include <lcom/lab3.h>

#include <stdbool.h>

#include <stdint.h>

//#include <timer.c>

#define IRQ_KB 1

#define DELAY_US 20000

#define EXIT_CODE 0x81

#define I_O_BUFFER 0x60

static uint32_t scancode;

int main(int argc, char *argv[]) {

  // sets the language of LCF messages (can be either EN-US or PT-PT)

  lcf_set_language("EN-US");

  // enables to log function invocations that are being "wrapped" by LCF

  // [comment this out if you don't want/need it]

  lcf_trace_calls("/home/lcom/labs/lab3/trace.txt");

  // enables to save the output of printf function calls on a file

  // [comment this out if you don't want/need it]

  lcf_log_output("/home/lcom/labs/lab3/output.txt");

  // handles control over to LCF

  // [LCF handles command line arguments and invokes the right function]

  if (lcf_start(argc, argv))

    return 1;

  // LCF clean up tasks

  // [must be the last statement before return]

  lcf_cleanup();

  return 0;

}

void (kbc_ih)()

{

  sys_inb(I_O_BUFFER, &scancode);

}

int(kbd_test_scan)() {

  /* To be completed by the students */

  int ipc_status;

  uint8_t r, bit_no=0;

  message msg;

  int hook_id=bit_no;

  uint8_t scan_arr[2] = {0,0};

  scan_arr[0]=scancode & 0xFF;

  scan_arr[1]=scancode & 0xFF00;

  sys_irqsetpolicy(IRQ_KB,IRQ_REENABLE|IRQ_EXCLUSIVE,&hook_id);

  //kbc_ih();

  printf("%x\n",scancode);

   while( 1)//(scancode & 0xFF) != EXIT_CODE )

 { /* You may want to use a different condition */

     /* Get a request message. */

     // printf("1\n");

     //printf("cont:%d, time:%d\n\n",cont/60,time);

     if ( (r = driver_receive(ANY, &msg, &ipc_status)) != 0 ) 

     { 

        printf("driver_receive failed with: %d", r);

       continue;

    }

    if (is_ipc_notify(ipc_status)) { /* received notification */

        switch (_ENDPOINT_P(msg.m_source)) {

            case HARDWARE: /* hardware interrupt notification */				

                if (msg.m_notify.interrupts  & BIT(0)) { /* subscribed interrupt */

                   kbd_print_scancode((scancode & 0xFF & 0x80),2,scan_arr );

               }

                //printf("msg:%x\n",msg.m_notify.interrupts);

                break;

            default:

                //printf("2\n");

                break; /* no other notifications expected: do nothing */	

        }

    } else {

     // printf("3\n"); /* received a standard message, not a notification */

        /* no standard messages expected: do nothing */

    }

 }

 if(timer_unsubscribe_int()!=0) return 1;

sys_irqrmpolicy(&hook_id);

  return 0;

}

int(kbd_test_poll)() {

  /* To be completed by the students */

  printf("%s is not yet implemented!\n", __func__);

  return 1;

}

int(kbd_test_timed_scan)(uint8_t n) {

  /* To be completed by the students */

  printf("%s is not yet implemented!\n", __func__);

  return 1;

}

#include <lcom/lcf.h>

#include <lcom/timer.h>

#include <stdint.h>

#include "i8254.h"

uint32_t cont=0;

int hook_id;

int (timer_set_frequency)(uint8_t timer, uint32_t freq) {

  /* To be implemented by the students */

  uint8_t conf;

  timer_get_conf(timer,&conf);

  uint32_t tudo;

  uint8_t msb,lsb;

  tudo=(TIMER_FREQ/freq);

  util_get_MSB(tudo,&msb);

  util_get_LSB(tudo,&lsb);

  //printf("%x\n%x\n%x\n%d\n",tudo,msb,lsb,timer);

  if(timer==0)

  {

    conf=(conf&0xF);

    conf = (conf  | TIMER_SEL0 | TIMER_LSB_MSB);

  if(sys_outb(TIMER_CTRL, conf)!=0) return 1;

  if(sys_outb(TIMER_0, lsb)!=0) return 1;

  if(sys_outb(TIMER_0, msb)!=0) return 1;

  }

  if(timer==1)

  {

    conf=(conf&0xF);

    conf = (conf | TIMER_SEL1 | TIMER_LSB_MSB);

  if(sys_outb(TIMER_CTRL, conf)!=0) return 1;

  if(sys_outb(TIMER_1, lsb)!=0) return 1;

  if(sys_outb(TIMER_1, msb)!=0) return 1;

  }

  if(timer==2)

  {

    conf=(conf&0xF);

    conf = (conf | TIMER_SEL2 | TIMER_LSB_MSB);

  if(sys_outb(TIMER_CTRL, conf)!=0) return 1;

  if(sys_outb(TIMER_2, lsb)!=0) return 1;

  if(sys_outb(TIMER_2, msb)!=0) return 1;

  }

  return 0;

}

int (timer_subscribe_int)(uint8_t *bit_no) {

    /* To be implemented by the students */

  //printf("%s is not yet implemented!\n", __func__);

 /*  int policy;

  sys_irqrmpolicy(&policy); */

  hook_id=*bit_no;

  if(sys_irqsetpolicy(IRQ_TIMER,IRQ_REENABLE,&hook_id)!=0) return 1;

  return 0;

}

int (timer_unsubscribe_int)() {

  /* To be implemented by the students */

// printf("%s is not yet implemented!\n", __func__);

  if(sys_irqrmpolicy(&hook_id)!=0) return 1;

  return 0;

}

void (timer_int_handler)() {

  /* To be implemented by the students */

  //printf("%s is not yet implemented!\n", __func__);

  cont=cont+1;

}

int (timer_get_conf)(uint8_t timer, uint8_t *st) {

  /* To be implemented by the students */

  uint8_t rbc = (TIMER_RB_CMD|TIMER_RB_SEL(4)|TIMER_RB_SEL(timer));

  if(sys_outb(TIMER_CTRL,rbc)!=0) return 1;

  if(timer==0)

  return (util_sys_inb(TIMER_0,st));

  if(timer==1)

  return (util_sys_inb(TIMER_1,st));

  if(timer==2)

  return (util_sys_inb(TIMER_2,st));

  return 1;

  //printf("%s is not yet implemented!\n", __func__);

}

int (timer_display_conf)(uint8_t timer, uint8_t st,

                        enum timer_status_field field) {

  /* To be implemented by the students */

  union timer_status_field_val val;

  if(field==tsf_all)

  {

    val.byte=st; 

  }

 if(field==tsf_initial)

  {

    //printf("%d\n",tsf_initial);

  if(((st&0x30)>>4)==0)

  val.in_mode=INVAL_val;

  if(((st&0x30)>>4)==1)

  val.in_mode=LSB_only;

  if(((st&0x30)>>4)==2)

  val.in_mode=MSB_only;

  if(((st&0x30)>>4)==3)

  val.in_mode=MSB_after_LSB;

  }

  if(field==tsf_mode)

  {

    //printf("%x\n",st);

    val.count_mode=((st&0xE)>>1);

    /* printf("%x\n",val.count_mode);

    val.count_mode=(val.count_mode>>1);

    printf("%x\n",val.count_mode); */

  //val.count_mode=(st&0x1C)/4;

 if (val.count_mode==6)

 val.count_mode=2;

 if (val.count_mode==7)

 val.count_mode=3;

  }

  if(field==tsf_base ) //BCD

  {

    //printf("%d\n",tsf_base);

    if((st&BIT(0))==1)

    val.bcd=true;

    else val.bcd=false;

  }

 return( timer_print_config(timer, field, val));

  //printf("%s is not yet implemented!\n", __func__);

  //return 0;

}

#include <lcom/lcf.h>

#include <stdint.h>

int(util_get_LSB)(uint16_t val, uint8_t *lsb) {

  /* To be implemented by the students */

  //printf("%s is not yet implemented!\n", __func__);

  *lsb=val&0xFF;

  return 0;

}

int(util_get_MSB)(uint16_t val, uint8_t *msb) {

  /* To be implemented by the students */

  //printf("%s is not yet implemented!\n", __func__);

  *msb=(val&0xFF00)>>8;

  return 0;

}

int (util_sys_inb)(int port, uint8_t *value) {

  /* To be implemented by the students */

  uint32_t b32;

 if(sys_inb(port,&b32)!=0)return 1;

 //printf("%x",b32);

 *value=b32&0xFF;

 //printf("%x\n",*value);

  //printf("%s is not yet implemented!\n", __func__);

  return 0;

}

/* a = 133

b = a & 0x0F

1000 0101

 */