정말죄송하지만..소스분석을좀 부탁해도될까요

//CMOS에서 rgb값을 얻어오는 디바이스 드라이버
//SRAM에서 cr, y, cb값을 가지고 rgb변환을 하도록한다.
#include <linux/config.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <asm/uaccess.h>
#include <asm/hardware.h>
#include <asm/irq.h>
#include <asm/param.h>
#include <asm/ioctl.h>
#include <linux/signal.h>
#include <linux/ioport.h>
#include <linux/interrupt.h>

#define GPIO_MAJOR 240
#define GPIO_NAME "CAMERA"
#define FLAG_ADDRESS 0xf1820000
#define SRAM_ADDRESS 0xf1830000
#define FLAG_ADDRESS_RANGE 2
#define SRAM_ADDRESS_RANGE 153600
#define IRQ_CMOS IRQ_GPIO(27)

static void cmos_interrupt(int irq, void *dev_id, struct pt_regs *regs);

static pid_t id;
unsigned int *pFlag;
unsigned int *pSRAM;
unsigned short ycbcr422[76800];
unsigned short frameinfo;
unsigned short pFlagTRUE=0;
unsigned short rgb[76800];
unsigned char edgeFlag = 0;

#define EDGEFLAG _IO(0xbd,0)

static void cmos_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{

// 인터럽트
int i,j,k,l;
int Y1,Y2,Cb1,Cr1=0,Cr2=0;
int r,g,b;

disable_irq(IRQ_CMOS);
*pFlag = 0x00;

memcpy(ycbcr422,pSRAM,76800*2);

k=0; l=0; Cr1=0; Cr2=0;
if(edgeFlag)
// 엣지 플레그가 1일 경우
{
for(j=0;j<239;j++){
// 240 pixel
for(i=0;i<319;i++) {
// 320 pixel

Y1 = ycbcr422[k+1] - ycbcr422[k];
Y2 = ycbcr422[k+320] - ycbcr422[k++];

Y1 = Y1*Y1;
Y2 = Y2*Y2;

r = (Y1 > 16777216) ? 0xff00 : 0;
g = (Y2 > 16777216) ? 0xff00 : 0;

rgb[l++] = (r&0xf800)|(g&0xf800)|((r>>5)&0x7e0)|((g>>5)&0x7e0)|((r>>11)&0x1f)|((g>>11)&0x1f);
}
l++;
k++;
}
}else
// 엣지 플레그가 0일 경우
{
for(j=0;j<240;j++)
for(i=0;i<320;i+=2){
// Cr1 = j ? Cr2 : (ycbcr422[k+2] & 0xff)-128; 속도 향상을 위해...
Y1 = (ycbcr422[k] & 0xff00);
Cb1= (ycbcr422[k++] & 0xff) - 128;
Y2 = (ycbcr422[k] & 0xff00);
Cr2= (ycbcr422[k++] & 0xff) - 128;

r = Y1 + 351*Cr1;
g = Y1 - 179*Cr1 - 86*Cb1;
b = Y1 + 443*Cb1;

r = r>0xff00 ? 0xff00 : r<0 ? 0x0: r;
g = g>0xff00 ? 0xff00 : g<0 ? 0x0: g;
b = b>0xff00 ? 0xff00 : b<0 ? 0x0: b;

rgb[l++] = (r&0xf800) | ((g>>5)&0x7e0) | ((b>>11)&0x1f);

r = Y2 + 351*Cr2;
g = Y2 - 179*Cr2 - 86*Cb1;
b = Y2 + 443*Cb1;

r = r>0xff00 ? 0xff00 : r<0 ? 0x0: r;
g = g>0xff00 ? 0xff00 : g<0 ? 0x0: g;
b = b>0xff00 ? 0xff00 : b<0 ? 0x0: b;

rgb[l++] = (r&0xf800) | ((g>>5)&0x7e0) | ((b>>11)&0x1f);
}
}
kill_proc(id,SIGUSR2,1);
}

ssize_t cis_write(struct file *inode, const char *gdata, size_t length, loff_t *off_what)
{
get_user(id,(int *)gdata);
// gdata 의 사이즈만큼 *gdata을 id로 복사 한다.
enable_irq(IRQ_CMOS);
// IRQ_CMOS 허가

return length;
}

ssize_t cis_read(struct file *flip, char *buf, size_t count, loff_t *l)
{ //rgb를 읽어 오는것 open후에도 rgb값을 얻어오려는 것같음.
copy_to_user(buf,rgb,153600);
// rgb에서 buf로 153600 만큼 복사 한다.

return 153600;
}

static int cis_ioctl(struct inode *m_inode, struct file *mfile, unsigned int cmd, unsigned long gdata)
{//디바이스드라이브가 제대로 적재되고 나서 설정값을 바꿀필요가 있을때 loctl함수를 부른다.
switch(cmd) {
// cmd 판별
case EDGEFLAG:
// cmd 가 EDGEFLAG 일경우
////////////////////////
edgeFlag = edgeFlag ? 0: 1;
// edgeFlag 가 1일 경우 0을 0일 경우 1을 넣는다.
break;
default:
break;
}
return 0;
}

static int cis_open(struct inode *inode, struct file *filp){
int res;
unsigned int gafr;

//gafr = 0x3; //gpio16
gafr = (0x3 << 22); //gpio27
GAFR0_U &= ~gafr;

gafr = 0x1;
GPDR1 &= ~gafr;

GPDR(IRQ_TO_GPIO_2_80(IRQ_CMOS)) &= ~GPIO_bit(IRQ_TO_GPIO_2_80(IRQ_CMOS));
// gpio의 입출력 방향 설정
set_GPIO_IRQ_edge(IRQ_TO_GPIO_2_80(IRQ_CMOS),GPIO_FALLING_EDGE);
// gpio의 IRQ 를 FALLING_EDGE일때 동작 설정

res = request_irq(IRQ_CMOS,&cmos_interrupt,SA_INTERRUPT,"CMOS",NULL);
// 인터럽트를 등록
//request_irq이함수로 인터럽트 사용시 이것을 사용하겠다고 요청.
if(res < 0){
// 실패시 -1 리턴
printk(KERN_ERR "%s: Request for IRQ %d failed\n",__FUNCTION__,IRQ_CMOS);
return -1;
}

pFlag = (unsigned int *)FLAG_ADDRESS;//pFlag의 주소를 잡아준다.
pSRAM = (unsigned int *)SRAM_ADDRESS;//pSRAM의 주소를 잡아준다.

MOD_INC_USE_COUNT;
return 0;
}

static int cis_release(struct inode *inode, struct file *filp)
{
// 드라이버 정리
free_irq(IRQ_CMOS,NULL);
disable_irq(IRQ_CMOS);

MOD_DEC_USE_COUNT;
return 0;
}

static struct file_operations cis_fops = {//커널에서는 어떤 디바이스라도
//파일과 같은 접근 하므로 구조체로 정의.
read: cis_read,
write: cis_write,
ioctl: cis_ioctl,
open: cis_open,
release: cis_release,
};

int init_module(void){
// 드라이버 초기화

int result;
result =register_chrdev(GPIO_MAJOR,"GPIO INTERRUPT",&cis_fops);
// 문자 디바이스 드라이버를 커널에 등록
//드라이버 등록 함수로 주장치번호 디바이스이름 파일조작함수인터페이스를 등록한다.

if(result < 0) {
// 등록 실패시
printk(KERN_WARNING"Can't get major %d\n",GPIO_MAJOR);
return result;
}

if(!check_region(FLAG_ADDRESS,FLAG_ADDRESS_RANGE))
//디바이스가 사용랗 번지주소가 유효한지 검사하는 함수.
// 영역 검사
// 영역이 사용중이 아닐때
// 영역 요청
request_region(FLAG_ADDRESS,FLAG_ADDRESS_RANGE,GPIO_NAME);
//주소가 유효하다면 request_region으로 이주소를 점유
else
{
// 사용중일때?
printk("driver : unable to use the address\n");
unregister_chrdev(GPIO_MAJOR ,GPIO_NAME);
return -1;
}

if(!check_region(SRAM_ADDRESS,SRAM_ADDRESS_RANGE))
// SRAM 영역 검사
// 영역이 사용중이 아닐때
// 영역 요청
request_region(SRAM_ADDRESS,SRAM_ADDRESS_RANGE,GPIO_NAME);
else
{
// 사용 중일때?
printk("driver : unable to use the address\n");
unregister_chrdev(GPIO_MAJOR ,GPIO_NAME);
return -1;
}

return 0;
}

void cleanup_module(void){
// 클린업 함수
release_region(FLAG_ADDRESS,FLAG_ADDRESS_RANGE);//주소유효를 해제
release_region(SRAM_ADDRESS,SRAM_ADDRESS_RANGE);

if(unregister_chrdev(GPIO_MAJOR ,GPIO_NAME))//장치 특수 번호를 해제하여 커널이
//디바이스를 사용하지않도록한다.
printk("driver : %s DRIVER CLEANUP FALLED\n",GPIO_NAME);

return;
}