// This function is called when a /dev/osprdX file is finally closed.
// (If the file descriptor was dup2ed, this function is called only when the
// last copy is closed.)
static int osprd_close_last(struct inode *inode, struct file *filp)
{
	if (filp) {
		osprd_info_t *d = file2osprd(filp);
		int filp_writable = filp->f_mode & FMODE_WRITE;

		// EXERCISE: If the user closes a ramdisk file that holds
		// a lock, release the lock.  Also wake up blocked processes
		// as appropriate.
		
		if (filp->f_flags & F_OSPRD_LOCKED) {
			if (filp_writable) {
				if (d->write_lock == 1) d->write_lock = 0;
				else eprintk("file attempted to unlock write lock it didn't have\n");			
			}
			else {
				osp_spin_lock(&(d->mutex));

				if (d->read_lock > 0) d->read_lock--;
				else eprintk("file attempted to unlock read lock it didn't have\n");
				osp_spin_unlock(&(d->mutex));
			}			
		}

		wake_up_all(&(d->blockq));
	}

	return 0;
}

static void run_hw_break_test(int is_write_test)
{
	test_complete = 0;
	init_simple_test();
	if (is_write_test) {
		ts.tst = hw_write_break_test;
		ts.name = "hw_write_break_test";
	} else {
		ts.tst = hw_access_break_test;
		ts.name = "hw_access_break_test";
	}
	/* Activate test with initial breakpoint */
	kgdb_breakpoint();
	hw_break_val_access();
	if (is_write_test) {
		if (test_complete == 2) {
			eprintk("kgdbts: ERROR %s broke on access\n",
				ts.name);
			hwbreaks_ok = 0;
		}
		hw_break_val_write();
	}
	kgdb_breakpoint();

	if (test_complete == 1)
		return;

	eprintk("kgdbts: ERROR %s test failed\n", ts.name);
	hwbreaks_ok = 0;
}

static int indirect_data(struct scsi_cmnd *scmd, struct srp_cmd *cmd,
			 struct srp_indirect_buf *id,
			 enum dma_data_direction dir, rdma_io_t rdma_io)
{
	struct iu_entry *iue = (struct iu_entry *) scmd->SCp.ptr;
	struct srp_target *target = iue->target;
	struct srp_direct_buf *md;
	struct scatterlist dummy, *sg = scmd->request_buffer;
	dma_addr_t token = 0;
	long err;
	unsigned int done = 0;
	int nmd, nsg;

	nmd = id->table_desc.len / sizeof(struct srp_direct_buf);

	dprintk("%p %u %u %u %u %d %d %d\n",
		iue, scmd->request_bufflen, scmd->bufflen,
		id->len, scmd->offset, nmd,
		cmd->data_in_desc_cnt, cmd->data_out_desc_cnt);

	if ((dir == DMA_FROM_DEVICE && nmd == cmd->data_in_desc_cnt) ||
	    (dir == DMA_TO_DEVICE && nmd == cmd->data_out_desc_cnt)) {
		md = &id->desc_list[0];
		goto rdma;
	}

	md = dma_alloc_coherent(target->dev, id->table_desc.len,
				 &token, GFP_KERNEL);
	if (!md) {
		eprintk("Can't get dma memory %u\n", id->table_desc.len);
		return 0;
	}

	sg_init_one(&dummy, md, id->table_desc.len);
	sg_dma_address(&dummy) = token;
	err = rdma_io(iue, &dummy, 1, &id->table_desc, 1, DMA_TO_DEVICE,
		      id->table_desc.len);
	if (err < 0) {
		eprintk("Error copying indirect table %ld\n", err);
		goto free_mem;
	}

rdma:
	nsg = dma_map_sg(target->dev, sg, scmd->use_sg, DMA_BIDIRECTIONAL);
	if (!nsg) {
		eprintk("fail to map %p %d\n", iue, scmd->use_sg);
		goto free_mem;
	}

	err = rdma_io(iue, sg, nsg, md, nmd, dir,
		      min(scmd->request_bufflen, id->len));
	dma_unmap_sg(target->dev, sg, nsg, DMA_BIDIRECTIONAL);

free_mem:
	if (token)
		dma_free_coherent(target->dev, id->table_desc.len, md, token);

	return done;
}

/*
 * osprd_process_request(d, req)
 *   Called when the user reads or writes a sector.
 *   Should perform the read or write, as appropriate.
 */
static void osprd_process_request(osprd_info_t *d, struct request *req)
{
  size_t offset;
  size_t num_bytes;

	if (!blk_fs_request(req)) {
		end_request(req, 0);
		return;
	}

	// EXERCISE: Perform the read or write request by copying data between
	// our data array and the request's buffer.
	// Hint: The 'struct request' argument tells you what kind of request
	// this is, and which sectors are being read or written.
	// Read about 'struct request' in <linux/blkdev.h>.
	// Consider the 'req->sector', 'req->current_nr_sectors', and
	// 'req->buffer' members, and the rq_data_dir() function.

  if (req->sector < 0 || req->sector >= nsectors)
  {
    // sector_t is defined as an unsigned long in <linux/types.h>
    eprintk("Invalid sector requested: [%lu]. max sectors: [%i]\n", (unsigned long)req->sector, nsectors);
    end_request(req, 0);
  }

  offset = req->sector * SECTOR_SIZE;

  // If the number of requested sectors would reach the end of the disk
  // use as many sectors as possible until the end is reached
  if(req->sector + req->current_nr_sectors > nsectors)
  {
    num_bytes = (nsectors - req->sector) * SECTOR_SIZE;
    eprintk("Requested sector [%lu] with [%u] additional sectors.\n", (unsigned long)req->sector, req->current_nr_sectors);
    eprintk("Using [%u] additional sectors instead.\n", num_bytes / SECTOR_SIZE);
  }
  else
  {
    num_bytes = req->current_nr_sectors * SECTOR_SIZE;
  }

  // According to http://www.makelinux.net/ldd3/chp-16-sect-3
  // it is save to dereference req->buffer and write to it.

  // Note from @ipetkov: I'm not sure if req->buffer needs to
  // be resized at all, I'm assuming linux will allocate the
  // memory before the request is sent. No issues are apparent
  // from the first 8 default test cases.
  spin_lock(&d->mutex);

  if(rq_data_dir(req) == READ)
    memcpy(req->buffer, d->data + offset, num_bytes);
  else // WRITE
    memcpy(d->data + offset, req->buffer, num_bytes);

  spin_unlock(&d->mutex);

	end_request(req, 1);
}

/*
 * osprd_process_request(d, req)
 *   Called when the user reads or writes a sector.
 *   Should perform the read or write, as appropriate.
 */
static void osprd_process_request(osprd_info_t *d, struct request *req)
{
        // Declare variables at the beginning
        // Calculate where to starta and the amount of data needed to copy
        int data_size = req->current_nr_sectors * SECTOR_SIZE;
        int data_offset = req->sector * SECTOR_SIZE;

        // Check for a bad request
        if (!blk_fs_request(req)) {
                end_request(req, 0);
                return;
        }

        // EXERCISE: Perform the read or write request by copying data between
        // our data array and the request's buffer.
        // Hint: The 'struct request' argument tells you what kind of request
        // this is, and which sectors are being read or written.
        // Read about 'struct request' in <linux/blkdev.h>.
        // Consider the 'req->sector', 'req->current_nr_sectors', and
        // 'req->buffer' members, and the rq_data_dir() function.

        // Your code here:
        
        // Check to see if we are trying to write to nonexistant sectors
        if(req->sector + req->current_nr_sectors > nsectors)
        {
                eprintk("Trying to write to nonexistant sectors\n");
                end_request(req, 0);
        }
        
        // Read from the RAMDISK
        // Copy the data in the requested sectors into the buffer
        if(rq_data_dir(req) == READ)
        {
                memcpy(req->buffer, d->data + data_offset, data_size);
        }
        
        // Write to the RAMDISK
        // Copy the data in the buffer into the requested sectors
        else if(rq_data_dir(req) == WRITE)
        {
                memcpy(d->data + data_offset, req->buffer, data_size);
        }
        
        // Trying to perform an invalid action
        else
        {
                eprintk("Neither a read nor a write\n");
                end_request(req,0);
        }
        
        end_request(req, 1);
}

static int emul_sstep_put(char *put_str, char *arg)
{
	if (!arch_needs_sstep_emulation) {
		char *ptr = &put_str[11];
		if (put_str[1] != 'T' || put_str[2] != '0')
			return 1;
		kgdb_hex2long(&ptr, &sstep_thread_id);
		return 0;
	}
	switch (sstep_state) {
	case 1:
		/* validate the "g" packet to get the IP */
		kgdb_hex2mem(&put_str[1], (char *)kgdbts_gdb_regs,
			 NUMREGBYTES);
		gdb_regs_to_pt_regs(kgdbts_gdb_regs, &kgdbts_regs);
		v2printk("Stopped at IP: %lx\n",
			 instruction_pointer(&kgdbts_regs));
		/* Want to stop at IP + break instruction size by default */
		sstep_addr = cont_addr + BREAK_INSTR_SIZE;
		break;
	case 2:
		if (strncmp(put_str, "$OK", 3)) {
			eprintk("kgdbts: failed sstep break set\n");
			return 1;
		}
		break;
	case 3:
		if (strncmp(put_str, "$T0", 3)) {
			eprintk("kgdbts: failed continue sstep\n");
			return 1;
		} else {
			char *ptr = &put_str[11];
			kgdb_hex2long(&ptr, &sstep_thread_id);
		}
		break;
	case 4:
		if (strncmp(put_str, "$OK", 3)) {
			eprintk("kgdbts: failed sstep break unset\n");
			return 1;
		}
		/* Single step is complete so continue on! */
		sstep_state = 0;
		return 0;
	default:
		eprintk("kgdbts: ERROR failed sstep put emulation\n");
	}

	/* Continue on the same test line until emulation is complete */
	ts.idx--;
	return 0;
}

static int bd6084gu_get_alc_level(struct bd6084gu_driver_data *drvdata)
{
	u8 level = 0;

	if(drvdata->mode == ALC_MODE) {
		if(bd6084gu_read(drvdata->client, 0x0C, &level))
			eprintk("Error while read register(0x13).\n");
		dprintk("alc level: %d\n", level);
	}
	else {
		eprintk("Current mode is not ALC mode\n");
	}

	return level;
}

pid_list_t
delete_check_deadlock_list (pid_list_t head,pid_list_t tail, pid_t current_pid)
{
	if (current_pid <0)
	{
		eprintk ("error delete");
		return NULL;
	}
	else
	{
		pid_list_t curr = head;
		while (curr->pid != current_pid)
		{
			curr = curr->next;
			if (curr == NULL)
			{
				eprintk ("can't find current_pid");
				return NULL;
			}
		}
		if (curr == head && curr== tail)
		{
			head = NULL;
			tail = NULL;
			kfree(curr);
		}
		else if (curr == head)
		{
			head = head->next;
			head->prev = NULL;
			kfree(curr);
		}
		else if (curr == tail)
		{
			tail = tail->prev;
			tail->next = NULL;
			kfree (curr);
		}
		else
		{
			curr->next->prev = curr->prev;
			curr->prev->next = curr->next;
			kfree(curr);
		}
		
	}
	return head;
}

/********************************************
 * Functions
 ********************************************/
static int aat28xx_setup_version(struct aat28xx_driver_data *drvdata)
{
	if(!drvdata)
		return -ENODEV;

	if(drvdata->version == 2862) {
		drvdata->cmds.normal = aat2862bl_normal_tbl;
		drvdata->cmds.alc = aat2862bl_alc_tbl;
		drvdata->cmds.sleep = aat2862bl_sleep_tbl;
		drvdata->reg_addrs.bl_m = AAT2862BL_REG_BLM;
		drvdata->reg_addrs.bl_s = AAT2862BL_REG_BLS;
		drvdata->reg_addrs.fade = AAT2862BL_REG_FADE;
		drvdata->reg_addrs.ldo_ab = AAT2862BL_REG_LDOAB;
		drvdata->reg_addrs.ldo_cd = AAT2862BL_REG_LDOCD;
		drvdata->reg_addrs.ldo_en = AAT2862BL_REG_LDOEN;
	}
	else if(drvdata->version == 2870) {
		drvdata->cmds.normal = aat2870bl_normal_tbl;
		drvdata->cmds.alc = aat2870bl_alc_tbl;
		drvdata->cmds.sleep = aat2870bl_sleep_tbl;
		drvdata->reg_addrs.bl_m = AAT2870BL_REG_BLM;
		drvdata->reg_addrs.ldo_ab = AAT2870BL_REG_LDOAB;
		drvdata->reg_addrs.ldo_cd = AAT2870BL_REG_LDOCD;
		drvdata->reg_addrs.ldo_en = AAT2870BL_REG_LDOEN;
	}
	else {
		eprintk("Not supported version!!\n");
		return -ENODEV;
	}

	return 0;
}

void ua_establish_for_session(struct iscsi_session *sess, u32 lun,
			      u8 asc, u8 ascq)
{
	struct list_head *l = &sess->ua_hash[ua_hashfn(lun)];
	struct ua_entry *ua = kmem_cache_alloc(ua_cache, GFP_KERNEL);
	struct ua_entry *e;

	if (!ua) {
		eprintk("%s", "Failed to alloc ua");
		return;
	}

	ua->asc = asc;
	ua->ascq = ascq;
	ua->lun = lun;
	ua->session = sess;
	INIT_LIST_HEAD(&ua->entry);

	spin_lock(&sess->ua_hash_lock);
	/* One UA per occurrence of an event */
	list_for_each_entry(e, l, entry) {
		if (e->session == sess && e->lun == lun &&
				e->asc == asc && e->ascq == ascq &&
				e->session->exp_cmd_sn == sess->exp_cmd_sn) {
			spin_unlock(&sess->ua_hash_lock);
			ua_free(ua);
			return;
		}
	}
	list_add_tail(&ua->entry, l);
	spin_unlock(&sess->ua_hash_lock);

	dprintk_ua(ua, sess, lun);
}

static void lm3530_sleep(struct lm3530_driver_data *drvdata)
{
	if (!drvdata || drvdata->state == SLEEP_STATE)
		return;

	dprintk("operation mode is %s\n", (drvdata->mode == NORMAL_MODE) ? "normal_mode" : "alc_mode");
	
	switch (drvdata->mode) {
		case NORMAL_MODE:
			drvdata->state = SLEEP_STATE;
			lm3530_set_table(drvdata, drvdata->cmds.sleep);
			break;

		case ALC_MODE:
			/* LGE_CHANGE
			 * Remove ALC mode
			 * 2010-07-26. [email protected]
			 */
			//drvdata->state = SLEEP_STATE;
			//lm3530_set_table(drvdata, drvdata->cmds.sleep);
			//udelay(500);
			//break;

		default:
			eprintk("Invalid Mode\n");
			break;
	}

	if (drvdata->client && gpio_is_valid(drvdata->gpio)) {
		gpio_tlmm_config(GPIO_CFG(drvdata->gpio, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
		bl_config_gpio(0);
		udelay(10);
		gpio_set_value(drvdata->gpio, 0);
	}	
}

static int check_and_rewind_pc(char *put_str, char *arg)
{
	unsigned long addr = lookup_addr(arg);
	int offset = 0;

	kgdb_hex2mem(&put_str[1], (char *)kgdbts_gdb_regs,
		 NUMREGBYTES);
	gdb_regs_to_pt_regs(kgdbts_gdb_regs, &kgdbts_regs);
	v2printk("Stopped at IP: %lx\n", instruction_pointer(&kgdbts_regs));
#ifdef CONFIG_X86
	/* On x86 a breakpoint stop requires it to be decremented */
	if (addr + 1 == kgdbts_regs.ip)
		offset = -1;
#endif
	if (strcmp(arg, "silent") &&
		instruction_pointer(&kgdbts_regs) + offset != addr) {
		eprintk("kgdbts: BP mismatch %lx expected %lx\n",
			   instruction_pointer(&kgdbts_regs) + offset, addr);
		return 1;
	}
#ifdef CONFIG_X86
	/* On x86 adjust the instruction pointer if needed */
	kgdbts_regs.ip += offset;
#endif
	return 0;
}

/*
 * osprd_process_request(d, req)
 *	 Called when the user reads or writes a sector.
 *	 Should perform the read or write, as appropriate.
 */
static void osprd_process_request(osprd_info_t *d, struct request *req)
{
	void *data_offset;
	unsigned int data_length;

	if (!blk_fs_request(req)) {
		end_request(req, 0);
		return;
	}

	// EXERCISE: Perform the read or write request by copying data between
	// our data array and the request's buffer.
	// Hint: The 'struct request' argument tells you what kind of request
	// this is, and which sectors are being read or written.
	// Read about 'struct request' in <linux/blkdev.h>.
	// Consider the 'req->sector', 'req->current_nr_sectors', and
	// 'req->buffer' members, and the rq_data_dir() function.

	data_offset = d->data + (SECTOR_SIZE * req->sector);
	data_length = req->current_nr_sectors * SECTOR_SIZE;

	// TODO: include a test for out-of-range read/writes
	if (rq_data_dir(req) == WRITE)
		memcpy(data_offset, req->buffer, data_length);
	else if (rq_data_dir(req) == READ)
		memcpy(req->buffer, data_offset, data_length);
	else {
		eprintk("Unrecognized command.\n");
		end_request(req, 0);
	}

	end_request(req, 1);
}

static int bd6084gu_set_table(struct bd6084gu_driver_data *drvdata, struct bd6084gu_ctrl_tbl *ptbl)
{
	unsigned int i = 0;

	if (ptbl == NULL) {
		eprintk("input ptr is null\n");
		return -EIO;
	}

	for( ;;) {
		if (ptbl->reg == 0xFF) {
			if (ptbl->val != 0xfe)
				udelay(ptbl->val);
			else
				break;
		}	
		else {
			if(bd6084gu_write(drvdata->client, ptbl->reg, ptbl->val) != 0)
				dprintk("i2c failed addr:%d, value:%d\n", ptbl->reg, ptbl->val);
		}
		ptbl++;
		i++;
	}
	return 0;
}

static void aat28xx_sleep(struct aat28xx_driver_data *drvdata)
{
	if (!drvdata || drvdata->state == SLEEP_STATE)
		return;

	dprintk("operation mode is %s\n", (drvdata->mode == NORMAL_MODE) ? "normal_mode" : "alc_mode");
	
	switch (drvdata->mode) {
		case NORMAL_MODE:
			drvdata->state = SLEEP_STATE;
			aat28xx_set_table(drvdata, drvdata->cmds.sleep);
			break;

		case ALC_MODE:
			/*           
                     
                                      
    */
			//drvdata->state = SLEEP_STATE;
			//aat28xx_set_table(drvdata, drvdata->cmds.sleep);
			//udelay(500);
			//break;

		default:
			eprintk("Invalid Mode\n");
			break;
	}
}

static int parse_nullio_params(struct iet_volume *volume, char *params)
{
	int err = 0;
	char *p, *q;

	while ((p = strsep(&params, ",")) != NULL) {
		substring_t args[MAX_OPT_ARGS];
		int token;
		if (!*p)
			continue;
		iet_strtolower(p);
		token = match_token(p, tokens, args);
		switch (token) {
		case opt_blk_cnt:
			q = match_strdup(&args[0]);
			if (!q)
				return -ENOMEM;
			volume->blk_cnt = simple_strtoull(q, NULL, 10);
			kfree(q);
			break;
		case opt_ignore:
			break;
		default:
			eprintk("Unknown %s\n", p);
			return -EINVAL;
			break;
		}
	}
	return err;
}

static void leds_brightness_set(struct led_classdev *led_cdev, enum led_brightness value)
{
	struct aat28xx_driver_data *drvdata = dev_get_drvdata(led_cdev->dev->parent);
	int brightness;
	int next;

	if (!drvdata) {
		eprintk("Error getting drvier data\n");
		return;
	}

	brightness = aat28xx_get_intensity(drvdata);

	next = value * drvdata->max_intensity / LED_FULL;
	/* If value is not 0, should not backlight off by bongkyu.kim */
	if (value !=0 && next == 0)
		next = 1;
		
	dprintk("input brightness value=%d]\n", next);

	if (brightness != next) {
		dprintk("brightness[current=%d, next=%d]\n", brightness, next);
		aat28xx_send_intensity(drvdata, next);
	}
}

static void emul_sstep_get(char *arg)
{
	if (!arch_needs_sstep_emulation) {
		fill_get_buf(arg);
		return;
	}
	switch (sstep_state) {
	case 0:
		v2printk("Emulate single step\n");
		/* Start by looking at the current PC */
		fill_get_buf("g");
		break;
	case 1:
		/* set breakpoint */
		break_helper("Z0", NULL, sstep_addr);
		break;
	case 2:
		/* Continue */
		fill_get_buf("c");
		break;
	case 3:
		/* Clear breakpoint */
		break_helper("z0", NULL, sstep_addr);
		break;
	default:
		eprintk("kgdbts: ERROR failed sstep get emulation\n");
	}
	sstep_state++;
}

int v9fs_get_idpool(struct v9fs_idpool *p)
{
	int i = 0;
	int error;

retry:
	if (idr_pre_get(&p->pool, GFP_KERNEL) == 0)
		return 0;

	if (down_interruptible(&p->lock) == -EINTR) {
		eprintk(KERN_WARNING, "Interrupted while locking\n");
		return -1;
	}

	/* no need to store exactly p, we just need something non-null */
	error = idr_get_new(&p->pool, p, &i);
	up(&p->lock);

	if (error == -EAGAIN)
		goto retry;
	else if (error)
		return -1;

	return i;
}

/*
 * osprd_process_request(d, req)
 *   Called when the user reads or writes a sector.
 *   Should perform the read or write, as appropriate.
 */
static void osprd_process_request(osprd_info_t *d, struct request *req)
{
	if (!blk_fs_request(req)) {
		end_request(req, 0);
		return;
	}

	// EXERCISE: Perform the read or write request by copying data between
	// our data array and the request's buffer.
	// Hint: The 'struct request' argument tells you what kind of request
	// this is, and which sectors are being read or written.
	// Read about 'struct request' in <linux/blkdev.h>.
	// Consider the 'req->sector', 'req->current_nr_sectors', and
	// 'req->buffer' members, and the rq_data_dir() function.

	// Your code here.
    unsigned long offset = req->sector*SECTOR_SIZE;
    unsigned long dataSize = req->current_nr_sectors*SECTOR_SIZE;
    
    if (rq_data_dir(req)==READ) {
        osp_spin_lock(&(d->mutex));
        memcpy(req->buffer, d->data+offset, dataSize);
        osp_spin_unlock(&(d->mutex));
    }else if (rq_data_dir(req)==WRITE){
        osp_spin_lock(&(d->mutex));
        memcpy(d->data+offset, req->buffer, dataSize);
        osp_spin_unlock(&(d->mutex));
    }else{
        end_request(req,1);
    }
    
	eprintk("Should process request...\n");

	end_request(req, 1);
}