void machine_restart(char *command)
{
if ((!in_interrupt() && !in_atomic()) || oops_in_progress)
/*
* Only unblank the console if we are called in enabled
* context or a bust_spinlocks cleared the way for us.
*/
console_unblank();
_machine_restart(command);
}
void machine_restart(char *command)
{
if (_machine_restart)
_machine_restart(command);
#ifdef CONFIG_SMP
preempt_disable();
smp_send_stop();
#endif
do_kernel_restart(command);
mdelay(1000);
pr_emerg("Reboot failed -- System halted\n");
local_irq_disable();
while (1);
}
long gioctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct vm_area_struct *vma;
#ifdef CONFIG_TIVO_DEVEL
extern void sw_watchdog_threads_hold(void);
extern void sw_watchdog_threads_release(void);
#endif
if (!arg)
{
printk(KERN_ERR "[gen_ioctl] Invalid arg\n");
return -EINVAL;
}
if (_IOC_TYPE(cmd) != GIOCTL_IOC_MAGIC)
{
printk(KERN_ERR "[gen_ioctl] cmd (0x%x) mismatch, " "called with 0x%x while expecting 0x%x\n", cmd, _IOC_TYPE(cmd),
GIOCTL_IOC_MAGIC);
return -EINVAL;
}
switch (cmd)
{
#ifdef CONFIG_TIVO_MOJAVE
case GO_BIST:
{
extern void emergency_sync(void);
extern void _machine_restart(void);
extern unsigned long get_RAM_size();
unsigned long *p = (unsigned long *) (KSEG1+get_RAM_size()-PAGE_SIZE);
/*
* flush all disk buffers
*/
emergency_sync();
/*Disable Interrupts*/
local_irq_disable();
memset(p,0,PAGE_SIZE);
*p++ = 0x42495354; /*BIST*/
*p++ = 1; /*Version*/
strcpy(p, arg); /*Boot Parameters*/
_machine_restart();
}
#endif
case CRASHALLASSRT:
return tivocrashallassert(arg);
#ifdef CONFIG_TICK_KILLER
case TICK_KILLER:
return tick_killer_start(arg);
#endif
case UPDATE_EXEC_CTX:
/*Ineffective ioctl. Handling for the backward compatibility purposes.
* Has be removed.*/
return 0;
#ifdef CONFIG_KSTACK_GUARD
case TEST_KSTACK_GUARD:
test_kstack_guard_check(current);
return 0;
#endif
case TEST_SGAT_DIO:
{
struct sgat_dio_fops gfops;
sgat_dio_req dio_req;
int c;
int k = 'z';
struct scatterlist *p;
sgat_dio_get_default_fops(&gfops);
if (sgat_dio_init_req(&gfops, &dio_req, (sgat_dio_hdr_t *) arg))
{
printk("Error: sgat_dio_init_req\n");
return -EINVAL;
}
if (sgat_dio_build_sg_list(&gfops, &dio_req, 1))
{
printk("Error: sgat_dio_build_sg_list\n");
return -EINVAL;
}
p = (struct scatterlist *)dio_req.sclist;
for (c = 0; c < dio_req.k_useg; c++)
{
memset(p->address, k, p->length);
p++;
}
sgat_dio_exit_req(&gfops, &dio_req, 1);
return 0;
}
#ifdef CONFIG_TIVO_SATA_HOTPLUG
case SATA_UNPLUG_INT:
{
/* This is a blocking call */
int port, offset, regvalue;
port = 1; /* Currently hard coding to port 1 */
if (port >= NUM_SATA_PORTS)
return -EINVAL;
/* SATA STATUS port */
offset = MMIO_SATA_STATUS + port * PORT_OFFSET;
/* Check the status */
regvalue = mmio_inl(offset);
regvalue &= PHY_IN_BIST;
if (regvalue)
return 0;
/* If user request for non blocking */
if (arg & 0x2)
{
/* Any positive number is treated error output of command (not ioctl error).
*/
return 1;
}
/* Now we have to wait for interrupt */
//return sata_wait_for_IRQ(port, offset, PHY_IN_BIST);
return 1;
}
case SATA_PLUG_INT:
{
/* This is a blocking call */
int port, offset, regvalue;
port = 1; /* Currently hard coding to port 1 */
if (port >= NUM_SATA_PORTS)
return -EINVAL;
/* SATA STATUS port */
offset = MMIO_SATA_STATUS + port * PORT_OFFSET;
/* Check the status */
regvalue = mmio_inl(offset);
regvalue &= PHY_IS_RDY;
if (regvalue)
return 0;
/* If user request for non blocking */
if (arg & 0x2)
{
/* Any positive number is treated error output of command (not ioctl error).
*/
return 1;
}
/* Now we have to wait for interrupt */
//return sata_wait_for_irq(port, offset, PHY_IS_RDY);
return 1;
}
#endif
case LOCKMEM:
{
printk("Pretending to LOCKMEM %p\n", (void *)arg);
//struct iovec *iovec = (struct iovec *) arg;
//if ( pindown_pages(NULL, iovec, 1, 1, WRITE) )
// return -EINVAL;
return 0;
}
case UNLOCKMEM:
{
printk("Pretending to UNLOCKMEM %p\n", (void *)arg);
// struct iovec *iovec = (struct iovec *) arg;
// struct page **page_list;
// struct page **pg_list;
// unsigned int pg_addr;
// int pgcount,pg;
// pgcount = (((u_long)iovec->iov_base) +
// iovec->iov_len + PAGE_SIZE - 1)/PAGE_SIZE -
// ((u_long)iovec->iov_base)/PAGE_SIZE;
// pg_addr = (unsigned int )(iovec->iov_base) & (~(PAGE_SIZE-1));
// page_list = kmalloc(sizeof(struct page **) * pgcount, GFP_KERNEL);
// pg_list = page_list;
// for ( pg = 0; pg < pgcount; pg++){
// *(pg_list++) = virt_to_page(pg_addr);
// pg_addr += PAGE_SIZE;
// }
// unlock_pages(page_list);
// kfree(*page_list);
return 0;
}
case IS_PM_FWUPGD_REQD:
{
int ret = -EINVAL;
#if SKIP_SATA_PM_FW_UPGD
return -EACCES;
#endif
#ifdef CONFIG_TIVO_DEVEL
/* Turn off sw watchdog for a while */
sw_watchdog_threads_hold();
#endif
if (is_fw_upgd_reqd)
ret = is_fw_upgd_reqd();
#ifdef CONFIG_TIVO_DEVEL
sw_watchdog_threads_release();
#endif
return ret;
}
case DWNLD_SATA_PM_FW:
{
int ret = -EINVAL;
#if SKIP_SATA_PM_FW_UPGD
return -EACCES;
#endif
#ifdef CONFIG_TIVO_DEVEL
/* Turn off sw watchdog for a while until we complete
* upgrading FW in blocking PIO mode
*/
sw_watchdog_threads_hold();
#endif
if (upgd_fw_init)
ret = upgd_fw_init();
#ifdef CONFIG_TIVO_DEVEL
/*Trun on sw wdog */
sw_watchdog_threads_release();
#endif
return ret;
}
case GET_VMA_INFO:
{
struct vma_info_struct s;
copy_from_user(&s,(void *)arg,sizeof(s));
down_read(¤t->mm->mmap_sem);
vma = find_vma(current->mm, s.address);
if (!vma || vma->vm_start > s.address)
{
up_read(¤t->mm->mmap_sem);
return -ENOMEM;
}
s.start = vma->vm_start;
s.end = vma->vm_end-1;
s.read = (vma->vm_flags & VM_READ)!=0;
s.write = (vma->vm_flags & VM_WRITE)!=0;
s.exec = (vma->vm_flags & VM_EXEC)!=0;
s.shared = (vma->vm_flags & VM_SHARED)!=0;
s.offset = vma->vm_pgoff*PAGE_SIZE;
s.device=s.inode=0;
if (vma->vm_file)
{
s.device=vma->vm_file->f_dentry->d_inode->i_rdev;
s.inode=vma->vm_file->f_dentry->d_inode->i_ino;
}
up_read(¤t->mm->mmap_sem);
copy_to_user((void *)arg, &s, sizeof(s));
return 0;
}
}
// none of the above...
printk(KERN_ERR "gen_ioctl: Invalid command (0x%x)\n",cmd);
return -EINVAL;
}
int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
_machine_restart();
return 0;
}
void machine_restart(char *command)
{
_machine_restart(command);
}
void machine_restart(char *command)
{
if (_machine_restart)
_machine_restart(command);
}
