/*
* ex_prchars --
* Local routine to dump characters to the screen.
*/
static int
ex_prchars(SCR *sp, const CHAR_T *p, size_t *colp, size_t len,
u_int flags, int repeatc)
{
CHAR_T ch;
char *kp;
GS *gp;
size_t col, tlen, ts;
if (O_ISSET(sp, O_LIST))
LF_SET(E_C_LIST);
gp = sp->gp;
ts = O_VAL(sp, O_TABSTOP);
for (col = *colp; len--;)
if ((ch = *p++) == L('\t') && !LF_ISSET(E_C_LIST))
for (tlen = ts - col % ts;
col < sp->cols && tlen--; ++col) {
(void)ex_printf(sp,
"%c", repeatc ? repeatc : ' ');
if (INTERRUPTED(sp))
goto intr;
}
else {
kp = KEY_NAME(sp, ch);
tlen = KEY_COL(sp, ch);
/*
* Start a new line if the last character does not fit
* into the current line. The implicit new lines are
* not interruptible.
*/
if (col + tlen > sp->cols) {
col = 0;
(void)ex_puts(sp, "\n");
}
col += tlen;
if (!repeatc) {
(void)ex_puts(sp, kp);
if (INTERRUPTED(sp))
goto intr;
} else while (tlen--) {
(void)ex_printf(sp, "%c", repeatc);
if (INTERRUPTED(sp))
goto intr;
}
if (col == sp->cols) {
col = 0;
(void)ex_puts(sp, "\n");
}
}
intr: *colp = col;
return (0);
}
static void get_volumekey_matrix(const struct matrix_keymap_data *keymap_data,
unsigned short *volup_matrix, unsigned short *voldown_matrix)
{
int i;
unsigned int key;
unsigned short code;
bool vol_up_found = false;
bool vol_down_found = false;
for (i = keymap_data->keymap_size-1;
(vol_up_found == false || vol_down_found == false)
&& i >= 0; i--) {
key = keymap_data->keymap[i];
code = KEY_VAL(key);
if ((vol_down_found == false) && (code == KEY_VOLUMEDOWN)) {
vol_down_found = true;
*voldown_matrix = KEY_ROW(key)<<8 | KEY_COL(key);
} else if ((vol_up_found == false) && (code == KEY_VOLUMEUP)) {
vol_up_found = true;
*volup_matrix = KEY_ROW(key)<<8 | KEY_COL(key);
}
}
}
static void ep93xx_keypad_build_keycode(struct ep93xx_keypad *keypad)
{
struct ep93xx_keypad_platform_data *pdata = keypad->pdata;
struct input_dev *input_dev = keypad->input_dev;
unsigned int *key;
int i;
key = &pdata->matrix_key_map[0];
for (i = 0; i < pdata->matrix_key_map_size; i++, key++) {
int row = KEY_ROW(*key);
int col = KEY_COL(*key);
int code = KEY_VAL(*key);
keypad->matrix_keycodes[(row << 3) + col] = code;
__set_bit(code, input_dev->keybit);
}
}
static bool matrix_keypad_map_key(struct input_dev *input_dev,
unsigned int rows, unsigned int cols,
unsigned int row_shift, unsigned int key)
{
unsigned short *keymap = input_dev->keycode;
unsigned int row = KEY_ROW(key);
unsigned int col = KEY_COL(key);
unsigned short code = KEY_VAL(key);
if (row >= rows || col >= cols) {
dev_err(input_dev->dev.parent,
"%s: invalid keymap entry 0x%x (row: %d, col: %d, rows: %d, cols: %d)\n",
__func__, key, row, col, rows, cols);
return false;
}
keymap[MATRIX_SCAN_CODE(row, col, row_shift)] = code;
__set_bit(code, input_dev->keybit);
return true;
}
static int __devinit imx_keypad_probe(struct platform_device *pdev)
{
const struct matrix_keymap_data *keymap_data = pdev->dev.platform_data;
struct imx_keypad *keypad;
struct input_dev *input_dev;
struct resource *res;
int irq, error, i;
if (keymap_data == NULL) {
dev_err(&pdev->dev, "no keymap defined\n");
return -EINVAL;
}
irq = platform_get_irq(pdev, 0);
if (irq < 0) {
dev_err(&pdev->dev, "no irq defined in platform data\n");
return -EINVAL;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res == NULL) {
dev_err(&pdev->dev, "no I/O memory defined in platform data\n");
return -EINVAL;
}
res = request_mem_region(res->start, resource_size(res), pdev->name);
if (res == NULL) {
dev_err(&pdev->dev, "failed to request I/O memory\n");
return -EBUSY;
}
input_dev = input_allocate_device();
if (!input_dev) {
dev_err(&pdev->dev, "failed to allocate the input device\n");
error = -ENOMEM;
goto failed_rel_mem;
}
keypad = kzalloc(sizeof(struct imx_keypad), GFP_KERNEL);
if (!keypad) {
dev_err(&pdev->dev, "not enough memory for driver data\n");
error = -ENOMEM;
goto failed_free_input;
}
keypad->input_dev = input_dev;
keypad->irq = irq;
keypad->stable_count = 0;
setup_timer(&keypad->check_matrix_timer,
imx_keypad_check_for_events, (unsigned long) keypad);
keypad->mmio_base = ioremap(res->start, resource_size(res));
if (keypad->mmio_base == NULL) {
dev_err(&pdev->dev, "failed to remap I/O memory\n");
error = -ENOMEM;
goto failed_free_priv;
}
keypad->clk = clk_get(&pdev->dev, "kpp");
if (IS_ERR(keypad->clk)) {
dev_err(&pdev->dev, "failed to get keypad clock\n");
error = PTR_ERR(keypad->clk);
goto failed_unmap;
}
/* Search for rows and cols enabled */
for (i = 0; i < keymap_data->keymap_size; i++) {
keypad->rows_en_mask |= 1 << KEY_ROW(keymap_data->keymap[i]);
keypad->cols_en_mask |= 1 << KEY_COL(keymap_data->keymap[i]);
}
if (keypad->rows_en_mask > ((1 << MAX_MATRIX_KEY_ROWS) - 1) ||
keypad->cols_en_mask > ((1 << MAX_MATRIX_KEY_COLS) - 1)) {
dev_err(&pdev->dev,
"invalid key data (too many rows or colums)\n");
error = -EINVAL;
goto failed_clock_put;
}
dev_dbg(&pdev->dev, "enabled rows mask: %x\n", keypad->rows_en_mask);
dev_dbg(&pdev->dev, "enabled cols mask: %x\n", keypad->cols_en_mask);
/* Init the Input device */
input_dev->name = pdev->name;
input_dev->id.bustype = BUS_HOST;
input_dev->dev.parent = &pdev->dev;
input_dev->open = imx_keypad_open;
input_dev->close = imx_keypad_close;
input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
input_dev->keycode = keypad->keycodes;
input_dev->keycodesize = sizeof(keypad->keycodes[0]);
input_dev->keycodemax = ARRAY_SIZE(keypad->keycodes);
matrix_keypad_build_keymap(keymap_data, MATRIX_ROW_SHIFT,
keypad->keycodes, input_dev->keybit);
input_set_capability(input_dev, EV_MSC, MSC_SCAN);
input_set_drvdata(input_dev, keypad);
/* Ensure that the keypad will stay dormant until opened */
imx_keypad_inhibit(keypad);
error = request_irq(irq, imx_keypad_irq_handler, IRQF_DISABLED,
pdev->name, keypad);
if (error) {
dev_err(&pdev->dev, "failed to request IRQ\n");
goto failed_clock_put;
}
/* Register the input device */
error = input_register_device(input_dev);
if (error) {
dev_err(&pdev->dev, "failed to register input device\n");
goto failed_free_irq;
}
platform_set_drvdata(pdev, keypad);
device_init_wakeup(&pdev->dev, 1);
return 0;
failed_free_irq:
free_irq(irq, pdev);
failed_clock_put:
clk_put(keypad->clk);
failed_unmap:
iounmap(keypad->mmio_base);
failed_free_priv:
kfree(keypad);
failed_free_input:
input_free_device(input_dev);
failed_rel_mem:
release_mem_region(res->start, resource_size(res));
return error;
}
/*
* vs_line --
* Update one line on the screen.
*
* PUBLIC: int vs_line __P((SCR *, SMAP *, size_t *, size_t *));
*/
int
vs_line(SCR *sp, SMAP *smp, size_t *yp, size_t *xp)
{
unsigned char *kp;
GS *gp;
SMAP *tsmp;
size_t chlen = 0, cno_cnt, cols_per_screen, len, nlen;
size_t offset_in_char, offset_in_line, oldx, oldy;
size_t scno, skip_cols, skip_screens;
int dne, is_cached, is_partial, is_tab, no_draw;
int list_tab, list_dollar;
CHAR_T *p;
CHAR_T *cbp, *ecbp, cbuf[128];
ARG_CHAR_T ch = L('\0');
#if defined(DEBUG) && 0
vtrace(sp, "vs_line: row %u: line: %u off: %u\n",
smp - HMAP, smp->lno, smp->off);
#endif
/*
* If ex modifies the screen after ex output is already on the screen,
* don't touch it -- we'll get scrolling wrong, at best.
*/
no_draw = 0;
if (!F_ISSET(sp, SC_TINPUT_INFO) && VIP(sp)->totalcount > 1)
no_draw = 1;
if (F_ISSET(sp, SC_SCR_EXWROTE) && (size_t)(smp - HMAP) != LASTLINE(sp))
no_draw = 1;
/*
* Assume that, if the cache entry for the line is filled in, the
* line is already on the screen, and all we need to do is return
* the cursor position. If the calling routine doesn't need the
* cursor position, we can just return.
*/
is_cached = SMAP_CACHE(smp);
if (yp == NULL && (is_cached || no_draw))
return (0);
/*
* A nasty side effect of this routine is that it returns the screen
* position for the "current" character. Not pretty, but this is the
* only routine that really knows what's out there.
*
* Move to the line. This routine can be called by vs_sm_position(),
* which uses it to fill in the cache entry so it can figure out what
* the real contents of the screen are. Because of this, we have to
* return to whereever we started from.
*/
gp = sp->gp;
(void)gp->scr_cursor(sp, &oldy, &oldx);
(void)gp->scr_move(sp, smp - HMAP, 0);
/* Get the line. */
dne = db_get(sp, smp->lno, 0, &p, &len);
/*
* Special case if we're printing the info/mode line. Skip printing
* the leading number, as well as other minor setup. The only time
* this code paints the mode line is when the user is entering text
* for a ":" command, so we can put the code here instead of dealing
* with the empty line logic below. This is a kludge, but it's pretty
* much confined to this module.
*
* Set the number of columns for this screen.
* Set the number of chars or screens to skip until a character is to
* be displayed.
*/
cols_per_screen = sp->cols;
if (O_ISSET(sp, O_LEFTRIGHT)) {
skip_screens = 0;
skip_cols = smp->coff;
} else {
skip_screens = smp->soff - 1;
skip_cols = skip_screens * cols_per_screen;
}
list_tab = O_ISSET(sp, O_LIST);
if (F_ISSET(sp, SC_TINPUT_INFO))
list_dollar = 0;
else {
list_dollar = list_tab;
/*
* If O_NUMBER is set, the line doesn't exist and it's line
* number 1, i.e., an empty file, display the line number.
*
* If O_NUMBER is set, the line exists and the first character
* on the screen is the first character in the line, display
* the line number.
*
* !!!
* If O_NUMBER set, decrement the number of columns in the
* first screen. DO NOT CHANGE THIS -- IT'S RIGHT! The
* rest of the code expects this to reflect the number of
* columns in the first screen, regardless of the number of
* columns we're going to skip.
*/
if (O_ISSET(sp, O_NUMBER)) {
cols_per_screen -= O_NUMBER_LENGTH;
if ((!dne || smp->lno == 1) && skip_cols == 0) {
nlen = snprintf((char*)cbuf,
sizeof(cbuf), O_NUMBER_FMT,
(unsigned long)smp->lno);
(void)gp->scr_addstr(sp, (char*)cbuf, nlen);
}
}
}
/*
* Special case non-existent lines and the first line of an empty
* file. In both cases, the cursor position is 0, but corrected
* as necessary for the O_NUMBER field, if it was displayed.
*/
if (dne || len == 0) {
/* Fill in the cursor. */
if (yp != NULL && smp->lno == sp->lno) {
*yp = smp - HMAP;
*xp = sp->cols - cols_per_screen;
}
/* If the line is on the screen, quit. */
if (is_cached || no_draw)
goto ret1;
/* Set line cache information. */
smp->c_sboff = smp->c_eboff = 0;
smp->c_scoff = smp->c_eclen = 0;
/*
* Lots of special cases for empty lines, but they only apply
* if we're displaying the first screen of the line.
*/
if (skip_cols == 0) {
if (dne) {
if (smp->lno == 1) {
if (list_dollar) {
ch = L('$');
goto empty;
}
} else {
ch = L('~');
goto empty;
}
} else
if (list_dollar) {
ch = L('$');
empty: (void)gp->scr_addstr(sp,
(const char *)KEY_NAME(sp, ch),
KEY_LEN(sp, ch));
}
}
(void)gp->scr_clrtoeol(sp);
(void)gp->scr_move(sp, oldy, oldx);
return (0);
}
/* If we shortened this line in another screen, the cursor
* position may have fallen off.
*/
if (sp->lno == smp->lno && sp->cno >= len)
sp->cno = len - 1;
/*
* If we just wrote this or a previous line, we cached the starting
* and ending positions of that line. The way it works is we keep
* information about the lines displayed in the SMAP. If we're
* painting the screen in the forward direction, this saves us from
* reformatting the physical line for every line on the screen. This
* wins big on binary files with 10K lines.
*
* Test for the first screen of the line, then the current screen line,
* then the line behind us, then do the hard work. Note, it doesn't
* do us any good to have a line in front of us -- it would be really
* hard to try and figure out tabs in the reverse direction, i.e. how
* many spaces a tab takes up in the reverse direction depends on
* what characters preceded it.
*
* Test for the first screen of the line.
*/
if (skip_cols == 0) {
smp->c_sboff = offset_in_line = 0;
smp->c_scoff = offset_in_char = 0;
p = &p[offset_in_line];
goto display;
}
/* Test to see if we've seen this exact line before. */
if (is_cached) {
offset_in_line = smp->c_sboff;
offset_in_char = smp->c_scoff;
p = &p[offset_in_line];
/* Set cols_per_screen to 2nd and later line length. */
if (O_ISSET(sp, O_LEFTRIGHT) || skip_cols > cols_per_screen)
cols_per_screen = sp->cols;
goto display;
}
/* Test to see if we saw an earlier part of this line before. */
if (smp != HMAP &&
SMAP_CACHE(tsmp = smp - 1) && tsmp->lno == smp->lno) {
if (tsmp->c_eclen != tsmp->c_ecsize) {
offset_in_line = tsmp->c_eboff;
offset_in_char = tsmp->c_eclen;
} else {
offset_in_line = tsmp->c_eboff + 1;
offset_in_char = 0;
}
/* Put starting info for this line in the cache. */
smp->c_sboff = offset_in_line;
smp->c_scoff = offset_in_char;
p = &p[offset_in_line];
/* Set cols_per_screen to 2nd and later line length. */
if (O_ISSET(sp, O_LEFTRIGHT) || skip_cols > cols_per_screen)
cols_per_screen = sp->cols;
goto display;
}
scno = 0;
offset_in_line = 0;
offset_in_char = 0;
/* Do it the hard way, for leftright scrolling screens. */
if (O_ISSET(sp, O_LEFTRIGHT)) {
for (; offset_in_line < len; ++offset_in_line) {
chlen = (ch = (UCHAR_T)*p++) == L('\t') && !list_tab ?
TAB_OFF(scno) : KEY_COL(sp, ch);
if ((scno += chlen) >= skip_cols)
break;
}
/* Set cols_per_screen to 2nd and later line length. */
cols_per_screen = sp->cols;
/* Put starting info for this line in the cache. */
if (offset_in_line >= len) {
smp->c_sboff = offset_in_line;
smp->c_scoff = 255;
} else if (scno != skip_cols) {
smp->c_sboff = offset_in_line;
smp->c_scoff =
offset_in_char = chlen - (scno - skip_cols);
--p;
} else {
smp->c_sboff = ++offset_in_line;
smp->c_scoff = 0;
}
}
/* Do it the hard way, for historic line-folding screens. */
else {
for (; offset_in_line < len; ++offset_in_line) {
chlen = (ch = (UCHAR_T)*p++) == L('\t') && !list_tab ?
TAB_OFF(scno) : KEY_COL(sp, ch);
if ((scno += chlen) < cols_per_screen)
continue;
scno -= cols_per_screen;
/* Set cols_per_screen to 2nd and later line length. */
cols_per_screen = sp->cols;
/*
* If crossed the last skipped screen boundary, start
* displaying the characters.
*/
if (--skip_screens == 0)
break;
}
/* Put starting info for this line in the cache. */
if (scno != 0) {
smp->c_sboff = offset_in_line;
smp->c_scoff = offset_in_char = chlen - scno;
--p;
} else {
smp->c_sboff = ++offset_in_line;
smp->c_scoff = 0;
}
}
display:
/*
* Set the number of characters to skip before reaching the cursor
* character. Offset by 1 and use 0 as a flag value. Vs_line is
* called repeatedly with a valid pointer to a cursor position.
* Don't fill anything in unless it's the right line and the right
* character, and the right part of the character...
*/
if (yp == NULL ||
smp->lno != sp->lno || sp->cno < offset_in_line ||
offset_in_line + cols_per_screen < sp->cno) {
cno_cnt = 0;
/* If the line is on the screen, quit. */
if (is_cached || no_draw)
goto ret1;
} else
cno_cnt = (sp->cno - offset_in_line) + 1;
/* This is the loop that actually displays characters. */
ecbp = (cbp = cbuf) + sizeof(cbuf)/sizeof(CHAR_T) - 1;
for (is_partial = 0, scno = 0;
offset_in_line < len; ++offset_in_line, offset_in_char = 0) {
if ((ch = (UCHAR_T)*p++) == L('\t') && !list_tab) {
scno += chlen = TAB_OFF(scno) - offset_in_char;
is_tab = 1;
} else {
scno += chlen = KEY_COL(sp, ch) - offset_in_char;
is_tab = 0;
}
/*
* Only display up to the right-hand column. Set a flag if
* the entire character wasn't displayed for use in setting
* the cursor. If reached the end of the line, set the cache
* info for the screen. Don't worry about there not being
* characters to display on the next screen, its lno/off won't
* match up in that case.
*/
if (scno >= cols_per_screen) {
if (is_tab == 1) {
chlen -= scno - cols_per_screen;
smp->c_ecsize = smp->c_eclen = chlen;
scno = cols_per_screen;
} else {
smp->c_ecsize = chlen;
chlen -= scno - cols_per_screen;
smp->c_eclen = chlen;
if (scno > cols_per_screen)
is_partial = 1;
}
smp->c_eboff = offset_in_line;
/* Terminate the loop. */
offset_in_line = len;
}
/*
* If the caller wants the cursor value, and this was the
* cursor character, set the value. There are two ways to
* put the cursor on a character -- if it's normal display
* mode, it goes on the last column of the character. If
* it's input mode, it goes on the first. In normal mode,
* set the cursor only if the entire character was displayed.
*/
if (cno_cnt &&
--cno_cnt == 0 && (F_ISSET(sp, SC_TINPUT) || !is_partial)) {
*yp = smp - HMAP;
if (F_ISSET(sp, SC_TINPUT))
if (is_partial)
*xp = scno - smp->c_ecsize;
else
*xp = scno - chlen;
else
*xp = scno - 1;
if (O_ISSET(sp, O_NUMBER) &&
!F_ISSET(sp, SC_TINPUT_INFO) && skip_cols == 0)
*xp += O_NUMBER_LENGTH;
/* If the line is on the screen, quit. */
if (is_cached || no_draw)
goto ret1;
}
/* If the line is on the screen, don't display anything. */
if (is_cached || no_draw)
continue;
#define FLUSH { \
*cbp = '\0'; \
(void)gp->scr_waddstr(sp, cbuf, cbp - cbuf); \
cbp = cbuf; \
}
/*
* Display the character. We do tab expansion here because
* the screen interface doesn't have any way to set the tab
* length. Note, it's theoretically possible for chlen to
* be larger than cbuf, if the user set a impossibly large
* tabstop.
*/
if (is_tab)
while (chlen--) {
if (cbp >= ecbp)
FLUSH;
*cbp++ = TABCH;
}
else {
if (cbp + chlen >= ecbp)
FLUSH;
/* don't display half a wide character */
if (is_partial && CHAR_WIDTH(sp, ch) > 1) {
*cbp++ = ' ';
break;
}
/* XXXX this needs some rethinking */
if (INTISWIDE(ch)) {
/* Put a space before non-spacing char. */
if (CHAR_WIDTH(sp, ch) <= 0)
*cbp++ = L(' ');
*cbp++ = ch;
} else
for (kp = KEY_NAME(sp, ch) + offset_in_char;
chlen--;)
*cbp++ = (u_char)*kp++;
}
}
if (scno < cols_per_screen) {
/* If didn't paint the whole line, update the cache. */
smp->c_ecsize = smp->c_eclen = KEY_LEN(sp, ch);
smp->c_eboff = len - 1;
/*
* If not the info/mode line, and O_LIST set, and at the
* end of the line, and the line ended on this screen,
* add a trailing $.
*/
if (list_dollar) {
++scno;
chlen = KEY_LEN(sp, L('$'));
if (cbp + chlen >= ecbp)
FLUSH;
for (kp = KEY_NAME(sp, L('$')); chlen--;)
*cbp++ = *kp++;
}
/* If still didn't paint the whole line, clear the rest. */
if (scno < cols_per_screen)
(void)gp->scr_clrtoeol(sp);
}
/* Flush any buffered characters. */
if (cbp > cbuf)
FLUSH;
ret1: (void)gp->scr_move(sp, oldy, oldx);
return (0);
}
static int pm8058_kp_config_drv(int gpio_start, int num_gpios)
{
int rc;
struct pm8058_gpio kypd_drv = {
.direction = PM_GPIO_DIR_OUT,
.output_buffer = PM_GPIO_OUT_BUF_OPEN_DRAIN,
.output_value = 0,
.pull = PM_GPIO_PULL_NO,
.vin_sel = 2,
.out_strength = PM_GPIO_STRENGTH_LOW,
.function = PM_GPIO_FUNC_1,
.inv_int_pol = 1,
};
if (gpio_start < 0 || num_gpios < 0 || num_gpios > PM8058_GPIOS)
return -EINVAL;
while (num_gpios--) {
rc = pm8058_gpio_config(gpio_start++, &kypd_drv);
if (rc) {
pr_err("%s: FAIL pm8058_gpio_config(): rc=%d.\n",
__func__, rc);
return rc;
}
}
return 0;
}
static int pm8058_kp_config_sns(int gpio_start, int num_gpios)
{
int rc;
struct pm8058_gpio kypd_sns = {
.direction = PM_GPIO_DIR_IN,
.pull = PM_GPIO_PULL_UP_31P5,
.vin_sel = 2,
.out_strength = PM_GPIO_STRENGTH_NO,
.function = PM_GPIO_FUNC_NORMAL,
.inv_int_pol = 1,
};
if (gpio_start < 0 || num_gpios < 0 || num_gpios > PM8058_GPIOS)
return -EINVAL;
while (num_gpios--) {
rc = pm8058_gpio_config(gpio_start++, &kypd_sns);
if (rc) {
pr_err("%s: FAIL pm8058_gpio_config(): rc=%d.\n",
__func__, rc);
return rc;
}
}
return 0;
}
static int __devinit pmic8058_kp_probe(struct platform_device *pdev)
{
struct pmic8058_keypad_data *pdata = pdev->dev.platform_data;
struct pmic8058_kp *kp;
int rc, i;
unsigned short *keycodes;
u8 ctrl_val;
struct pm8058_chip *pm_chip;
pm_chip = platform_get_drvdata(pdev);
if (pm_chip == NULL) {
dev_err(&pdev->dev, "no parent data passed in\n");
return -EFAULT;
}
if (!pdata || !pdata->num_cols || !pdata->num_rows ||
pdata->num_cols > MATRIX_MAX_COLS ||
pdata->num_rows > MATRIX_MAX_ROWS ||
pdata->num_cols < MATRIX_MIN_COLS ||
pdata->num_rows < MATRIX_MIN_ROWS ||
!pdata->keymap) {
dev_err(&pdev->dev, "invalid platform data\n");
return -EINVAL;
}
if (pdata->rows_gpio_start < 0 || pdata->cols_gpio_start < 0) {
dev_err(&pdev->dev, "invalid gpio_start platform data\n");
return -EINVAL;
}
if (!pdata->scan_delay_ms || pdata->scan_delay_ms > MAX_SCAN_DELAY
|| pdata->scan_delay_ms < MIN_SCAN_DELAY ||
!is_power_of_2(pdata->scan_delay_ms)) {
dev_err(&pdev->dev, "invalid keypad scan time supplied\n");
return -EINVAL;
}
if (!pdata->row_hold_ns || pdata->row_hold_ns > MAX_ROW_HOLD_DELAY
|| pdata->row_hold_ns < MIN_ROW_HOLD_DELAY ||
((pdata->row_hold_ns % MIN_ROW_HOLD_DELAY) != 0)) {
dev_err(&pdev->dev, "invalid keypad row hold time supplied\n");
return -EINVAL;
}
if (pm8058_rev(pm_chip) == PM_8058_REV_1p0) {
if (!pdata->debounce_ms
|| !is_power_of_2(pdata->debounce_ms[0])
|| pdata->debounce_ms[0] > MAX_DEBOUNCE_A0_TIME
|| pdata->debounce_ms[0] < MIN_DEBOUNCE_A0_TIME) {
dev_err(&pdev->dev, "invalid debounce time supplied\n");
return -EINVAL;
}
} else {
if (!pdata->debounce_ms
|| ((pdata->debounce_ms[1] % 5) != 0)
|| pdata->debounce_ms[1] > MAX_DEBOUNCE_B0_TIME
|| pdata->debounce_ms[1] < MIN_DEBOUNCE_B0_TIME) {
dev_err(&pdev->dev, "invalid debounce time supplied\n");
return -EINVAL;
}
}
kp = kzalloc(sizeof(*kp), GFP_KERNEL);
if (!kp)
return -ENOMEM;
keycodes = kzalloc(MATRIX_MAX_SIZE * sizeof(keycodes), GFP_KERNEL);
if (!keycodes) {
rc = -ENOMEM;
goto err_alloc_mem;
}
platform_set_drvdata(pdev, kp);
kp->pdata = pdata;
kp->dev = &pdev->dev;
kp->keycodes = keycodes;
kp->pm_chip = pm_chip;
if (pm8058_rev(pm_chip) == PM_8058_REV_1p0)
kp->flags |= KEYF_FIX_LAST_ROW;
kp->input = input_allocate_device();
if (!kp->input) {
dev_err(&pdev->dev, "unable to allocate input device\n");
rc = -ENOMEM;
goto err_alloc_device;
}
kp->key_sense_irq = platform_get_irq(pdev, 0);
if (kp->key_sense_irq < 0) {
dev_err(&pdev->dev, "unable to get keypad sense irq\n");
rc = -ENXIO;
goto err_get_irq;
}
kp->key_stuck_irq = platform_get_irq(pdev, 1);
if (kp->key_stuck_irq < 0) {
dev_err(&pdev->dev, "unable to get keypad stuck irq\n");
rc = -ENXIO;
goto err_get_irq;
}
if (pdata->input_name)
kp->input->name = pdata->input_name;
else
kp->input->name = "PMIC8058 keypad";
if (pdata->input_phys_device)
kp->input->phys = pdata->input_phys_device;
else
kp->input->phys = "pmic8058_keypad/input0";
kp->input->dev.parent = &pdev->dev;
kp->input->id.bustype = BUS_HOST;
kp->input->id.version = 0x0001;
kp->input->id.product = 0x0001;
kp->input->id.vendor = 0x0001;
kp->input->evbit[0] = BIT_MASK(EV_KEY);
if (pdata->rep)
__set_bit(EV_REP, kp->input->evbit);
kp->input->keycode = keycodes;
kp->input->keycodemax = MATRIX_MAX_SIZE;
kp->input->keycodesize = sizeof(*keycodes);
for (i = 0; i < pdata->keymap_size; i++) {
unsigned int row = KEY_ROW(pdata->keymap[i]);
unsigned int col = KEY_COL(pdata->keymap[i]);
unsigned short keycode = KEY_VAL(pdata->keymap[i]);
keycodes[(row << 3) + col] = keycode;
__set_bit(keycode, kp->input->keybit);
}
__clear_bit(KEY_RESERVED, kp->input->keybit);
input_set_capability(kp->input, EV_MSC, MSC_SCAN);
input_set_drvdata(kp->input, kp);
rc = input_register_device(kp->input);
if (rc < 0) {
dev_err(&pdev->dev, "unable to register keypad input device\n");
goto err_get_irq;
}
memset(kp->keystate, 0xff, sizeof(kp->keystate));
memset(kp->stuckstate, 0xff, sizeof(kp->stuckstate));
rc = pmic8058_kpd_init(kp);
if (rc < 0) {
dev_err(&pdev->dev, "unable to initialize keypad controller\n");
goto err_kpd_init;
}
rc = pm8058_kp_config_sns(pdata->cols_gpio_start,
pdata->num_cols);
if (rc < 0) {
dev_err(&pdev->dev, "unable to configure keypad sense lines\n");
goto err_gpio_config;
}
rc = pm8058_kp_config_drv(pdata->rows_gpio_start,
pdata->num_rows);
if (rc < 0) {
dev_err(&pdev->dev, "unable to configure keypad drive lines\n");
goto err_gpio_config;
}
rc = request_irq(kp->key_sense_irq, pmic8058_kp_irq,
IRQF_TRIGGER_RISING, "pmic-keypad", kp);
if (rc < 0) {
dev_err(&pdev->dev, "failed to request keypad sense irq\n");
goto err_req_sense_irq;
}
rc = request_irq(kp->key_stuck_irq, pmic8058_kp_stuck_irq,
IRQF_TRIGGER_RISING, "pmic-keypad-stuck", kp);
if (rc < 0) {
dev_err(&pdev->dev, "failed to request keypad stuck irq\n");
goto err_req_stuck_irq;
}
rc = pmic8058_kp_read(kp, &ctrl_val, KEYP_CTRL, 1);
ctrl_val |= KEYP_CTRL_KEYP_EN;
rc = pmic8058_kp_write_u8(kp, ctrl_val, KEYP_CTRL);
__dump_kp_regs(kp, "probe");
device_init_wakeup(&pdev->dev, pdata->wakeup);
return 0;
err_req_stuck_irq:
free_irq(kp->key_sense_irq, NULL);
err_req_sense_irq:
err_gpio_config:
err_kpd_init:
input_unregister_device(kp->input);
kp->input = NULL;
err_get_irq:
input_free_device(kp->input);
err_alloc_device:
kfree(keycodes);
err_alloc_mem:
kfree(kp);
return rc;
}
static int __devexit pmic8058_kp_remove(struct platform_device *pdev)
{
struct pmic8058_kp *kp = platform_get_drvdata(pdev);
device_init_wakeup(&pdev->dev, 0);
free_irq(kp->key_stuck_irq, NULL);
free_irq(kp->key_sense_irq, NULL);
input_unregister_device(kp->input);
platform_set_drvdata(pdev, NULL);
kfree(kp->input->keycode);
kfree(kp);
return 0;
}
static struct platform_driver pmic8058_kp_driver = {
.probe = pmic8058_kp_probe,
.remove = __devexit_p(pmic8058_kp_remove),
.driver = {
.name = "pm8058-keypad",
.owner = THIS_MODULE,
#ifdef CONFIG_PM
.pm = &pm8058_kp_pm_ops,
#endif
},
};
static int __init pmic8058_kp_init(void)
{
return platform_driver_register(&pmic8058_kp_driver);
}
module_init(pmic8058_kp_init);
static void __exit pmic8058_kp_exit(void)
{
platform_driver_unregister(&pmic8058_kp_driver);
}
/*
* keypad controller should be initialized in the following sequence
* only, otherwise it might get into FSM stuck state.
*
* - Initialize keypad control parameters, like no. of rows, columns,
* timing values etc.,
* - configure rows and column gpios pull up/down.
* - set irq edge type.
* - enable the keypad controller.
*/
static int __devinit pmic8058_kp_probe(struct platform_device *pdev)
{
struct pmic8058_keypad_data *pdata = pdev->dev.platform_data;
struct pmic8058_kp *kp;
int rc, i;
unsigned short *keycodes;
u8 ctrl_val;
if (!pdata || !pdata->num_cols || !pdata->num_rows ||
pdata->num_cols > MATRIX_MAX_COLS ||
pdata->num_rows > MATRIX_MAX_ROWS ||
!pdata->keymap) {
dev_err(&pdev->dev, "invalid platform data\n");
return -EINVAL;
}
if (pdata->rows_gpio_start < 0 || pdata->cols_gpio_start < 0) {
dev_err(&pdev->dev, "invalid gpio_start platform data\n");
return -EINVAL;
}
if (!pdata->scan_delay_ms || pdata->scan_delay_ms > MAX_SCAN_DELAY
|| pdata->scan_delay_ms < MIN_SCAN_DELAY ||
!is_power_of_2(pdata->scan_delay_ms)) {
dev_err(&pdev->dev, "invalid keypad scan time supplied\n");
return -EINVAL;
}
rc = pm8058_read(PM8058_REV, &rev, 1);
pr_info("PMIC4 is at %X revision\n", rev);
if (rev == PMIC8058_REV_A0) {
if (!pdata->debounce_ms || !is_power_of_2(pdata->debounce_ms)
|| pdata->debounce_ms > MAX_DEBOUNCE_A0_TIME
|| pdata->debounce_ms < MIN_DEBOUNCE_A0_TIME) {
dev_err(&pdev->dev, "invalid debounce time supplied\n");
return -EINVAL;
}
} else {
if (!pdata->debounce_ms || ((pdata->debounce_ms % 5) != 0)
|| pdata->debounce_ms > MAX_DEBOUNCE_B0_TIME
|| pdata->debounce_ms < MIN_DEBOUNCE_B0_TIME) {
dev_err(&pdev->dev, "invalid debounce time supplied\n");
return -EINVAL;
}
}
kp = kzalloc(sizeof(*kp), GFP_KERNEL);
if (!kp)
return -ENOMEM;
keycodes = kzalloc(MATRIX_MAX_SIZE * sizeof(keycodes), GFP_KERNEL);
if (!keycodes) {
rc = -ENOMEM;
goto err_alloc_mem;
}
platform_set_drvdata(pdev, kp);
kp->pdata = pdata;
kp->dev = &pdev->dev;
kp->keycodes = keycodes;
/* REVISIT: actual revision with the fix */
if (rev <= PMIC8058_REV_B0)
kp->flags |= KEYF_FIX_LAST_ROW;
kp->input = input_allocate_device();
if (!kp->input) {
dev_err(&pdev->dev, "unable to allocate input device\n");
rc = -ENOMEM;
goto err_alloc_device;
}
kp->key_sense_irq = platform_get_irq(pdev, 0);
if (kp->key_sense_irq < 0) {
dev_err(&pdev->dev, "unable to get keypad sense irq\n");
rc = -ENXIO;
goto err_get_irq;
}
kp->key_stuck_irq = platform_get_irq(pdev, 1);
if (kp->key_stuck_irq < 0) {
dev_err(&pdev->dev, "unable to get keypad stuck irq\n");
rc = -ENXIO;
goto err_get_irq;
}
if (pdata->input_name)
kp->input->name = pdata->input_name;
else
kp->input->name = "PMIC8058 keypad";
if (pdata->input_phys_device)
kp->input->phys = pdata->input_phys_device;
else
kp->input->phys = "pmic8058_keypad/input0";
kp->input->dev.parent = &pdev->dev;
kp->input->id.bustype = BUS_HOST;
kp->input->id.version = 0x0001;
kp->input->id.product = 0x0001;
kp->input->id.vendor = 0x0001;
kp->input->evbit[0] = BIT_MASK(EV_KEY);
if (pdata->rep)
__set_bit(EV_REP, kp->input->evbit);
kp->input->keycode = keycodes;
kp->input->keycodemax = MATRIX_MAX_SIZE;
kp->input->keycodesize = sizeof(*keycodes);
/* build keycodes for faster scanning */
for (i = 0; i < pdata->keymap_size; i++) {
unsigned int row = KEY_ROW(pdata->keymap[i]);
unsigned int col = KEY_COL(pdata->keymap[i]);
unsigned short keycode = KEY_VAL(pdata->keymap[i]);
keycodes[(row << 3) + col] = keycode;
__set_bit(keycode, kp->input->keybit);
}
__clear_bit(KEY_RESERVED, kp->input->keybit);
input_set_capability(kp->input, EV_MSC, MSC_SCAN);
input_set_drvdata(kp->input, kp);
rc = input_register_device(kp->input);
if (rc < 0) {
dev_err(&pdev->dev, "unable to register keypad input device\n");
goto err_get_irq;
}
/* initialize keypad state */
memset(kp->keystate, 0xff, sizeof(kp->keystate));
rc = pmic8058_kpd_init(kp);
if (rc < 0) {
dev_err(&pdev->dev, "unable to initialize keypad controller\n");
goto err_kpd_init;
}
rc = pm8058_gpio_config_kypd_sns(pdata->cols_gpio_start,
pdata->num_cols);
if (rc < 0) {
dev_err(&pdev->dev, "unable to configure keypad sense lines\n");
goto err_gpio_config;
}
rc = pm8058_gpio_config_kypd_drv(pdata->rows_gpio_start,
pdata->num_rows);
if (rc < 0) {
dev_err(&pdev->dev, "unable to configure keypad drive lines\n");
goto err_gpio_config;
}
rc = request_irq(kp->key_sense_irq, pmic8058_kp_irq,
IRQF_TRIGGER_RISING, "pmic-keypad", kp);
if (rc < 0) {
dev_err(&pdev->dev, "failed to request keypad sense irq\n");
goto err_req_sense_irq;
}
rc = request_irq(kp->key_stuck_irq, pmic8058_kp_stuck_irq,
IRQF_TRIGGER_RISING, "pmic-keypad-stuck", kp);
if (rc < 0) {
dev_err(&pdev->dev, "failed to request keypad stuck irq\n");
goto err_req_stuck_irq;
}
rc = pmic8058_kp_read(kp, &ctrl_val, KEYP_CTRL, 1);
ctrl_val |= KEYP_CTRL_KEYP_EN;
rc = pmic8058_kp_write_u8(kp, ctrl_val, KEYP_CTRL);
__dump_kp_regs(kp, "probe");
device_init_wakeup(&pdev->dev, pdata->wakeup);
return 0;
err_req_stuck_irq:
free_irq(kp->key_sense_irq, NULL);
err_req_sense_irq:
err_gpio_config:
err_kpd_init:
input_unregister_device(kp->input);
kp->input = NULL;
err_get_irq:
input_free_device(kp->input);
err_alloc_device:
kfree(keycodes);
err_alloc_mem:
kfree(kp);
return rc;
}
