using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Threading;

namespace ConsoleApplication9
{
    internal class Program
    {
        private static void Main()
        {
            int g, rep;

            // Set up gpi pointer for direct register access
            
            // Switch GPIO 7..11 to output mode

            /************************************************************************\
             * You are about to change the GPIO settings of your computer.          *
             * Mess this up and it will stop working!                               *
             * It might be a good idea to 'sync' before running this program        *
             * so at least you still have your code changes written to the SD-card! *
            \************************************************************************/

            // Set GPIO pins 7-11 to output
            for (g = 7; g <= 11; g++)
            {
                Console.WriteLine("Setting up pi {0}",g);
                IO.INP_GPIO((uint)g); // must use INP_GPIO before we can use OUT_GPIO
                IO.OUT_GPIO((uint)g);
            }

            for (rep = 0; rep < 10; rep++)
            {
                Console.WriteLine("Cycle {0} of 10",rep);
                for (g = 7; g <= 11; g++)
                {
                    Console.WriteLine("Setting up pin {0}",g);
                    IO.GPIO_SET = (uint)(1 << g);
                    Thread.Sleep(333);
                }
                for (g = 7; g <= 11; g++)
                {
                    Console.WriteLine("Resetting pin {0}",g);
                    IO.GPIO_CLR = (uint)(1 << g);
                    Thread.Sleep(333);
                }
            }

            //dont try it
            /*Console.WriteLine("Testing max frequency");
            var sw = new Stopwatch();
            sw.Start();
            int cyclesCount = 100000;
            for(int i=0;i<cyclesCount;i++)
            {
                IO.GPIO_SET = (uint)(0x100);
                IO.GPIO_CLR = (uint)(0x100);
            }
            sw.Stop();
            Console.WriteLine("Emitted {0} cycles in {1}. Frequency {2}KHz",cyclesCount,sw.Elapsed,cyclesCount/sw.ElapsedMilliseconds);*/
        }
    }

    public static unsafe class IO
    {
        private const uint BCM2708_PERI_BASE = 0x20000000;
        private const uint GPIO_BASE = BCM2708_PERI_BASE + 0x200000; /* GPIO controller */

        private const uint PAGE_SIZE = (4 * 1024);
        private const uint BLOCK_SIZE = (4 * 1024);

        private static int mem_fd;
        private static byte* gpio_mem;
        private static byte* gpio_map;
        private static byte* spi0_mem;
        private static byte* spi0_map;


        // I/O access
        private static volatile uint* gpio;
        private static readonly void* NULL = (void*)0;

        //TODO: Find constants for libc open
        private const int O_RDWR = 02;
        private const int O_SYNC = 010000;

        //TODO: Find constants for mmap
        private const int PROT_READ = 0x1 /* page can be read */;
        private const int PROT_WRITE = 0x2 /* page can be written */;
        /*
         
#define PROT_EXEC   0x4      // page can be executed 
#define PROT_NONE   0x0      // page can not be accessed 
         */
        private static int MAP_SHARED = 0x01      /* Share changes */;
        private static int MAP_FIXED = 0x10      /* Interpret addr exactly */;
        /*
#define MAP_PRIVATE   0x02      // Changes are private
#define MAP_TYPE   0x0f      // Mask for type of mapping
#define MAP_FIXED   0x10      // Interpret addr exactly
#define MAP_ANONYMOUS   0x20      // don't use a file
         */

        // GPIO setup macros. Always use INP_GPIO(x) before using OUT_GPIO(x) or SET_GPIO_ALT(x,y)
        public static void INP_GPIO(uint g)
        {
            *(gpio + ((g) / 10)) &= ~(7u << (int)(((g) % 10) * 3));
        }

        public static void OUT_GPIO(uint g)
        {
            *(gpio + ((g) / 10)) |= 1u << (int)(((g) % 10) * 3);
        }

        private static void SET_GPIO_ALT(uint g, uint a)
        {
            *(gpio + (((g) / 10))) |= (((a) <= 3 ? (a) + 4 : (a) == 4 ? 3u : 2) << (int)(((g) % 10) * 3));
        }

        /// <summary>
        /// sets   bits which are 1 ignores bits which are 0
        /// </summary>
        public static uint GPIO_SET
        {
            set { *(gpio + 7) = value; }
        }

        /// <summary>
        /// clears bits which are 1 ignores bits which are 0
        /// </summary>
        public static uint GPIO_CLR
        {
            set { *(gpio + 10) = value; }
        }

        /// <summary>
        /// Get data 
        /// </summary>
        public static uint GPIO_IN0 { get { return *(gpio + 13); } }

        static IO()
        {
            setup_io();
        }

        /// <summary>
        /// Set up a memory regions to access GPIO
        /// </summary>
        private static void setup_io()
        {

            /* open /dev/mem */
            if ((mem_fd = open("/dev/mem", O_RDWR | O_SYNC)) < 0)
            {
                Console.WriteLine("can't open /dev/mem");
                throw new Exception();
            }

            /* mmap GPIO */

            // Allocate MAP block
            if ((gpio_mem = malloc(BLOCK_SIZE + (PAGE_SIZE - 1))) == NULL)
            {
                Console.WriteLine("allocation error");
                throw new Exception();
            }

            // Make sure pointer is on 4K boundary
            if ((ulong)gpio_mem % PAGE_SIZE != 0)
                gpio_mem += PAGE_SIZE - ((ulong)gpio_mem % PAGE_SIZE);

            // Now map it
            gpio_map = (byte*)mmap(
                gpio_mem,
                BLOCK_SIZE,
                PROT_READ | PROT_WRITE,
                MAP_SHARED | MAP_FIXED,
                mem_fd,
                GPIO_BASE
                                   );

            if ((long)gpio_map < 0)
            {
                Console.WriteLine("mmap error {0}", (int)gpio_map);
                throw new Exception();
            }

            // Always use volatile pointer!
            gpio = (uint*)gpio_map;
        }

        // setup_io
        [DllImport("libc.so.6")]
        static extern void* mmap(void* addr, uint length, int prot, int flags,
                  int fd, uint offset);

        [DllImport("libc.so.6")]
        static extern int open(string file, int mode /*, int permissions */);

        [DllImport("libc.so.6")]
        static extern byte* malloc(uint size);
    }
}