Пример #1
0
static ssize_t log_proc_write(struct file *f, const char *buf, size_t cnt, loff_t *pos) {
    int i;
#define MAX_ARGS 5
#define MAX_ARG_SIZE 32
    typedef char arg_t[MAX_ARG_SIZE];
    arg_t arg[MAX_ARGS];
    int argc;
    char cmd;
    bcmLogModuleInfo_t *pModInfo;
#define LOG_WR_KBUF_SIZE 128
    char kbuf[LOG_WR_KBUF_SIZE];

    if ((cnt > LOG_WR_KBUF_SIZE-1) || (copy_from_user(kbuf, buf, cnt) != 0))
        return -EFAULT;

    kbuf[cnt]=0;

    argc = sscanf(kbuf, "%c %s %s %s %s %s", &cmd, arg[0], arg[1], arg[2], arg[3], arg[4]);

    for (i=0; i<MAX_ARGS; ++i) {
        arg[i][MAX_ARG_SIZE-1] = '\0';
    }

    BCM_LOG_INFO(BCM_LOG_ID_LOG, "WRITE: cmd: %c, argc: %d", cmd, argc);
    for (i=0; i<argc-1; ++i) {
        BCM_LOG_INFO(BCM_LOG_ID_LOG, "arg[%d]: %s ", i, arg[i]);
    }

    switch ( cmd ) {
        BCM_LOGCODE(
            case 'g':
            {
                bcmLogLevel_t logLevel = str2val(arg[0]);
                if(argc == 2 && logLevel >= 0 && logLevel < BCM_LOG_LEVEL_MAX)
                    globalLogLevel = logLevel;
                else
                    BCM_LOG_ERROR(BCM_LOG_ID_LOG, "Invalid Parameter '%s'\n", arg[0]);
                break;
            } )

        BCM_LOGCODE(
            case 'r':
            {
                bcmPrint ("Global Log Level : %d\n", globalLogLevel);
                break;
            } )
Пример #2
0
/* Calls the appropriate function based on user command */
static int exec_command(const char *buf, size_t count, int fs_type)
{
#define MAX_ARGS 2
#define MAX_ARG_SIZE 32
    int i, argc = 0, val = 0;
    char cmd;
    u8 offset;
    char arg[MAX_ARGS][MAX_ARG_SIZE];
#if 0
    char temp_buf[20] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
#endif
#ifdef PROCFS_HOOKS
#define LOG_WR_KBUF_SIZE 128
    char kbuf[LOG_WR_KBUF_SIZE];

    if(fs_type == PROC_FS)
    {
        if ((count > LOG_WR_KBUF_SIZE-1) || 
            (copy_from_user(kbuf, buf, count) != 0))
            return -EFAULT;
    	kbuf[count]=0;
        argc = sscanf(kbuf, "%c %s %s", &cmd, arg[0], arg[1]);
    }
#endif

#ifdef SYSFS_HOOKS
    if(fs_type == SYS_FS)
        argc = sscanf(buf, "%c %s %s", &cmd, arg[0], arg[1]);
#endif

    if (argc <= 1) {
        BCM_LOG_NOTICE(BCM_LOG_ID_I2C, "Need at-least 2 arguments \n");
        return -EFAULT;
    }

    for (i=0; i<MAX_ARGS; ++i) {
        arg[i][MAX_ARG_SIZE-1] = '\0';
    }

    offset = (u8) simple_strtoul(arg[0], NULL, 0);
    if (argc == 3)
        val = (int) simple_strtoul(arg[1], NULL, 0);

    switch (cmd) {

#if 0
    case 'y':
        if (argc == 3) {
            if (val > 7) {
                BCM_LOG_INFO(BCM_LOG_ID_I2C, "Limiting byte count to 7 \n");
                val = 7;
            }
   		 	BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "Write Byte Stream: offset = %x, " 
   		 	              "count = %x \n", offset, val);
            for (i=0; i< val; i++) {
                BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "%x, ",temp_buf[i]);
            }
            temp_buf[0] = offset;
            bcm3450_write(temp_buf, val+1);
        }
        break;

    case 'z':
        if (argc == 3) {
            if (val > 8) {
                BCM_LOG_INFO(BCM_LOG_ID_I2C, "This test limits the byte stream" 
                             " count to 8 \n");
                val = 8;
            }
            for (i=0; i< val; i++) {
                BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "%x, ",temp_buf[i]);
            }
            temp_buf[0] = offset;
            bcm3450_read(temp_buf, val);
   		 	BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "Read Byte Stream: offset = %x, " 
   		 	              "count = %x \n", offset, val);
            for (i=0; i< val; i++) {
                BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "%x, ",temp_buf[i]);
            }
            BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "\n");
        }
        break;
#endif

    case 'b':
        if (argc == 3) {
   		 	BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "Write Byte: offset = %x, " 
   		 	              "val = %x \n", offset, val);
            bcm3450_write_byte(offset, (u8)val);
        }
        else {
            val = bcm3450_read_byte(offset);
   		 	BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "Read Byte: offset = %x, " 
   		 	              "val = %x \n", offset, val);
        }
        break;

    case 'w':
        if (argc == 3) {
   		 	BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "Write Word: offset = %x, " 
   		 	              "val = %x \n", offset, val);
            bcm3450_write_word(offset, (u16)val);
        }
        else {
            val = bcm3450_read_word(offset);
   		 	BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "Read Word: offset = %x, " 
   		 	              "val = %x \n", offset, val);
        }
        break;

    case 'd':	
        if (argc == 3) {
   		 	BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "Write Register: offset = %x, " 
   		 	              "val = %x \n", offset, val);
            bcm3450_write_reg(offset, val);
        }
        else {
            val = bcm3450_read_reg(offset);
   		 	BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "Read Register: offset = %x, "
   		 	              "val = %x \n", offset, val);
        }
        break;

    default:
        BCM_LOG_NOTICE(BCM_LOG_ID_I2C, "Invalid command. \n Valid commands: \n" 
                       "  Write Reg:   d offset val \n" 
                       "  Read Reg:    d offset \n" 
                       "  Write Word:  w offset val \n" 
                       "  Read Word:   w offset \n" 
                       "  Write Byte:  b offset val \n" 
                       "  Read Byte:   b offset \n" 
#if 0
                       "  Write Bytes: y offset count \n" 
                       "  Read Bytes:  z offset count \n"
#endif
                       );
        break;
    }
    return count;
}