/*! \brief Find matching index + offset. */
static int hhelem_free(hhash_t* tbl, uint32_t id, unsigned dist, value_t *val)
{
/* Remove from the source bitvector. */
hhelem_t *elm = &tbl->item[id];
elm->hop &= ~HOP_BIT(dist);
/* Copy value for future reference. */
elm = &tbl->item[(id + dist) % tbl->size];
if (val != NULL) {
memcpy(val, KEY_VAL(elm->d), sizeof(value_t));
}
/* Erase data from target element. */
if (tbl->mm.free) {
tbl->mm.free(elm->d);
elm->d = NULL;
}
/* Invalidate index. */
if (tbl->mm.free) {
tbl->mm.free(tbl->index);
tbl->index = NULL;
}
/* Update table weight. */
--tbl->weight;
return KNOT_EOK;
}
value_t *hhash_indexval(hhash_t* tbl, unsigned i)
{
if (tbl != NULL && tbl->index != NULL) {
return (value_t *)KEY_VAL(tbl->item[ tbl->index[i] ].d);
}
return 0;
}
static value_t *hhash_unsorted_iter_val(hhash_iter_t* i)
{
if (hhash_iter_finished(i)) {
return NULL;
}
return (value_t *)KEY_VAL(i->tbl->item[i->i].d);
}
static value_t *hhash_sorted_iter_val(hhash_iter_t* i)
{
if (hhash_iter_finished(i)) {
return NULL;
}
return (value_t *)KEY_VAL(hhash_sorted_iter_item(i));
}
/*
* ex_map -- :map[!] [input] [replacement]
* Map a key/string or display mapped keys.
*
* Historical note:
* Historic vi maps were fairly bizarre, and likely to differ in
* very subtle and strange ways from this implementation. Two
* things worth noting are that vi would often hang or drop core
* if the map was strange enough (ex: map X "xy$@x^V), or, simply
* not work. One trick worth remembering is that if you put a
* mark at the start of the map, e.g. map X mx"xy ...), or if you
* put the map in a .exrc file, things would often work much better.
* No clue why.
*
* PUBLIC: int ex_map __P((SCR *, EXCMD *));
*/
int
ex_map(SCR *sp, EXCMD *cmdp)
{
seq_t stype;
CHAR_T *input, *p;
stype = FL_ISSET(cmdp->iflags, E_C_FORCE) ? SEQ_INPUT : SEQ_COMMAND;
switch (cmdp->argc) {
case 0:
if (seq_dump(sp, stype, 1) == 0)
msgq(sp, M_INFO, stype == SEQ_INPUT ?
"132|No input map entries" :
"133|No command map entries");
return (0);
case 2:
input = cmdp->argv[0]->bp;
break;
default:
abort();
}
/*
* If the mapped string is #[0-9]* (and wasn't quoted) then store the
* function key mapping. If the screen specific routine has been set,
* call it as well. Note, the SEQ_FUNCMAP type is persistent across
* screen types, maybe the next screen type will get it right.
*/
if (input[0] == '#' && ISDIGIT((UCHAR_T)input[1])) {
for (p = input + 2; ISDIGIT((UCHAR_T)*p); ++p);
if (p[0] != '\0')
goto nofunc;
if (seq_set(sp, NULL, 0, input, cmdp->argv[0]->len,
cmdp->argv[1]->bp, cmdp->argv[1]->len, stype,
SEQ_FUNCMAP | SEQ_USERDEF))
return (1);
return (sp->gp->scr_fmap == NULL ? 0 :
sp->gp->scr_fmap(sp, stype, input, cmdp->argv[0]->len,
cmdp->argv[1]->bp, cmdp->argv[1]->len));
}
/* Some single keys may not be remapped in command mode. */
nofunc: if (stype == SEQ_COMMAND && input[1] == '\0')
switch (KEY_VAL(sp, input[0])) {
case K_COLON:
case K_ESCAPE:
case K_NL:
msgq(sp, M_ERR,
"134|The %s character may not be remapped",
KEY_NAME(sp, input[0]));
return (1);
default:
break;
}
return (seq_set(sp, NULL, 0, input, cmdp->argv[0]->len,
cmdp->argv[1]->bp, cmdp->argv[1]->len, stype, SEQ_USERDEF));
}
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);
}
}
value_t *hhash_find(hhash_t* tbl, const char* key, uint16_t len)
{
/* It is faster to scan index using binary search for low fill,
* as it doesn't present constant hashing penalty. */
if (tbl->index && tbl->weight < HHSCAN_THRESHOLD) {
int k = BIN_SEARCH_FIRST_GE_CMP(tbl, tbl->weight, CMP_LE, key, len) - 1;
if (k > -1) {
hhelem_t *found = tbl->item + tbl->index[k];
if (hhelem_isequal(found, key, len)) {
return (value_t *)KEY_VAL(found->d);
}
}
return NULL; /* Not found. */
}
return hhash_map(tbl, key, len, 0); /* Don't insert. */
}
int hhash_find_next(hhash_t* tbl, const char* key, uint16_t len, value_t** dst)
{
*dst = NULL;
if (tbl->weight == 0) {
return 1;
}
int k = BIN_SEARCH_FIRST_GE_CMP(tbl, tbl->weight, CMP_LE, key, len);
/* Found prev or equal, we want next */
if (k + 1 < tbl->weight) {
hhelem_t *found = tbl->item + tbl->index[k + 1];
*dst = (value_t *)KEY_VAL(found->d);
return 0;
} else {
return 1;
}
}
static ssize_t sysfs_key_pressed_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
struct pmic8xxx_kp *kp = platform_get_drvdata(pdev);
const struct pm8xxx_keypad_platform_data *pdata = kp->pdata;
const struct matrix_keymap_data *kepmap_data = pdata->keymap_data;
int i;
int key_pressed = 0;
for (i = kepmap_data->keymap_size-1;
i >= 0 ; i--) {
unsigned short code = KEY_VAL(kepmap_data->keymap[i]);
if (test_bit(code, kp->input->key)) {
key_pressed = 1;
break;
}
}
return sprintf(buf, "%d\n", key_pressed);
}
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;
}
int hhash_find_leq(hhash_t* tbl, const char* key, uint16_t len, value_t** dst)
{
*dst = NULL;
if (tbl->weight == 0) {
return 1;
}
int k = BIN_SEARCH_FIRST_GE_CMP(tbl, tbl->weight, CMP_LE, key, len) - 1;
if (k > -1) {
hhelem_t *found = tbl->item + tbl->index[k];
*dst = (value_t *)KEY_VAL(found->d);
/* Compare if found equal or predecessor. */
if (hhelem_isequal(found, key, len)) {
return 0; /* Exact match. */
} else {
return -1; /* Predecessor. */
}
}
/* No predecessor. */
return 1;
}
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);
}
}
}
/*
* sscr_insert --
* Take a line from the shell and insert it into the file.
*/
static int
sscr_insert(SCR *sp)
{
CHAR_T *endp, *p, *t;
SCRIPT *sc;
struct pollfd pfd[1];
recno_t lno;
size_t blen, len, tlen;
u_int value;
int nr, rval;
char *bp;
/* Find out where the end of the file is. */
if (db_last(sp, &lno))
return (1);
#define MINREAD 1024
GET_SPACE_RET(sp, bp, blen, MINREAD);
endp = bp;
/* Read the characters. */
rval = 1;
sc = sp->script;
more: switch (nr = read(sc->sh_master, endp, MINREAD)) {
case 0: /* EOF; shell just exited. */
sscr_end(sp);
rval = 0;
goto ret;
case -1: /* Error or interrupt. */
msgq(sp, M_SYSERR, "shell");
goto ret;
default:
endp += nr;
break;
}
/* Append the lines into the file. */
for (p = t = bp; p < endp; ++p) {
value = KEY_VAL(sp, *p);
if (value == K_CR || value == K_NL) {
len = p - t;
if (db_append(sp, 1, lno++, t, len))
goto ret;
t = p + 1;
}
}
if (p > t) {
len = p - t;
/*
* If the last thing from the shell isn't another prompt, wait
* up to 1/10 of a second for more stuff to show up, so that
* we don't break the output into two separate lines. Don't
* want to hang indefinitely because some program is hanging,
* confused the shell, or whatever.
*/
if (!sscr_matchprompt(sp, t, len, &tlen) || tlen != 0) {
pfd[0].fd = sc->sh_master;
pfd[0].events = POLLIN;
if (poll(pfd, 1, 100) > 0) {
memmove(bp, t, len);
endp = bp + len;
goto more;
}
}
if (sscr_setprompt(sp, t, len))
return (1);
if (db_append(sp, 1, lno++, t, len))
goto ret;
}
/* The cursor moves to EOF. */
sp->lno = lno;
sp->cno = len ? len - 1 : 0;
rval = vs_refresh(sp, 1);
ret: FREE_SPACE(sp, bp, blen);
return (rval);
}
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);
}
value_t *hhash_map(hhash_t* tbl, const char* key, uint16_t len, uint16_t mode)
{
if (tbl == NULL) {
return NULL;
}
/* Find an exact match in <id, id + HOP_LEN). */
uint32_t id = hash(key, len) % tbl->size;
int dist = find_match(tbl, id, key, len);
if (dist <= HOP_LEN) {
/* Found exact match, return value. */
hhelem_t *match = &tbl->item[(id + dist) % tbl->size];
return (value_t *)KEY_VAL(match->d);
}
/* We didn't find an exact match, continue only if inserting. */
if (!(mode & HHASH_INSERT)) {
return NULL;
} else if (tbl->weight >= tbl->size) { /* Or full table. */
return NULL;
}
/* Reduce distance to fit <id, id + HOP_LEN) */
dist = find_free(tbl, id);
if (dist < 0) { /* Did not find any fit. */
return NULL;
}
int empty = (id + dist) % tbl->size;
while (dist >= HOP_LEN) {
dist = reduce_dist(tbl, dist, &empty);
/* Couldn't reduce the distance, no fit available. */
if (dist < 0) {
return NULL;
}
}
/* Insert to given position. */
char *new_key = tbl->mm.alloc(tbl->mm.ctx, HHKEY_LEN + len);
if (new_key != NULL) {
memset(KEY_VAL(new_key), 0, sizeof(value_t));
memcpy(KEY_LEN(new_key), &len, sizeof(uint16_t));
memcpy(KEY_STR(new_key), key, len);
} else {
return NULL;
}
/* found free elm 'k' which is in <id, id + HOP_LEN) */
assert(tbl->item[empty].d == NULL);
tbl->item[id].hop |= HOP_BIT(dist);
tbl->item[empty].d = new_key;
++tbl->weight;
/* Free old index. */
if (tbl->index) {
if (tbl->mm.free) {
free(tbl->index);
}
tbl->index = NULL;
}
return (value_t *)KEY_VAL(new_key);
}
/*
* sscr_getprompt --
* Eat lines printed by the shell until a line with no trailing
* carriage return comes; set the prompt from that line.
*/
static int
sscr_getprompt(SCR *sp)
{
CHAR_T *endp, *p, *t, buf[1024];
SCRIPT *sc;
struct pollfd pfd[1];
recno_t lline;
size_t llen, len;
u_int value;
int nr;
endp = buf;
len = sizeof(buf);
/* Wait up to a second for characters to read. */
sc = sp->script;
pfd[0].fd = sc->sh_master;
pfd[0].events = POLLIN;
switch (poll(pfd, 1, 5 * 1000)) {
case -1: /* Error or interrupt. */
msgq(sp, M_SYSERR, "poll");
goto prompterr;
case 0: /* Timeout */
msgq(sp, M_ERR, "Error: timed out");
goto prompterr;
default: /* Characters to read. */
break;
}
/* Read the characters. */
more: len = sizeof(buf) - (endp - buf);
switch (nr = read(sc->sh_master, endp, len)) {
case 0: /* EOF. */
msgq(sp, M_ERR, "Error: shell: EOF");
goto prompterr;
case -1: /* Error or interrupt. */
msgq(sp, M_SYSERR, "shell");
goto prompterr;
default:
endp += nr;
break;
}
/* If any complete lines, push them into the file. */
for (p = t = buf; p < endp; ++p) {
value = KEY_VAL(sp, *p);
if (value == K_CR || value == K_NL) {
if (db_last(sp, &lline) ||
db_append(sp, 0, lline, t, p - t))
goto prompterr;
t = p + 1;
}
}
if (p > buf) {
memmove(buf, t, endp - t);
endp = buf + (endp - t);
}
if (endp == buf)
goto more;
/* Wait up 1/10 of a second to make sure that we got it all. */
switch (poll(pfd, 1, 100)) {
case -1: /* Error or interrupt. */
msgq(sp, M_SYSERR, "poll");
goto prompterr;
case 0: /* Timeout */
break;
default: /* Characters to read. */
goto more;
}
/* Timed out, so theoretically we have a prompt. */
llen = endp - buf;
endp = buf;
/* Append the line into the file. */
if (db_last(sp, &lline) || db_append(sp, 0, lline, buf, llen)) {
prompterr: sscr_end(sp);
return (1);
}
return (sscr_setprompt(sp, buf, llen));
}
/*
* 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;
}
/*
* v_z -- [count]z[count][-.+^<CR>]
* Move the screen.
*
* PUBLIC: int v_z(SCR *, VICMD *);
*/
int
v_z(SCR *sp, VICMD *vp)
{
recno_t lno;
e_key_t value;
/*
* The first count is the line to use. If the value doesn't
* exist, use the last line.
*/
if (F_ISSET(vp, VC_C1SET)) {
lno = vp->count;
if (!db_exist(sp, lno) && db_last(sp, &lno))
return (1);
} else
lno = vp->m_start.lno;
/* Set default return cursor line. */
vp->m_final.lno = lno;
vp->m_final.cno = vp->m_start.cno;
/*
* The second count is the displayed window size, i.e. the 'z' command
* is another way to get artificially small windows. Note, you can't
* grow beyond the size of the window.
*
* !!!
* A window size of 0 was historically allowed, and simply ignored.
* This could be much more simply done by modifying the value of the
* O_WINDOW option, but that's not how it worked historically.
*/
if (F_ISSET(vp, VC_C2SET) && vp->count2 != 0) {
if (vp->count2 > O_VAL(sp, O_WINDOW))
vp->count2 = O_VAL(sp, O_WINDOW);
if (vs_crel(sp, vp->count2))
return (1);
}
switch (vp->character) {
case '-': /* Put the line at the bottom. */
if (vs_sm_fill(sp, lno, P_BOTTOM))
return (1);
break;
case '.': /* Put the line in the middle. */
if (vs_sm_fill(sp, lno, P_MIDDLE))
return (1);
break;
case '+':
/*
* If the user specified a line number, put that line at the
* top and move the cursor to it. Otherwise, scroll forward
* a screen from the current screen.
*/
if (F_ISSET(vp, VC_C1SET)) {
if (vs_sm_fill(sp, lno, P_TOP))
return (1);
if (vs_sm_position(sp, &vp->m_final, 0, P_TOP))
return (1);
} else
if (vs_sm_scroll(sp, &vp->m_final, sp->t_rows, Z_PLUS))
return (1);
break;
case '^':
/*
* If the user specified a line number, put that line at the
* bottom, move the cursor to it, and then display the screen
* before that one. Otherwise, scroll backward a screen from
* the current screen.
*
* !!!
* Note, we match the off-by-one characteristics of historic
* vi, here.
*/
if (F_ISSET(vp, VC_C1SET)) {
if (vs_sm_fill(sp, lno, P_BOTTOM))
return (1);
if (vs_sm_position(sp, &vp->m_final, 0, P_TOP))
return (1);
if (vs_sm_fill(sp, vp->m_final.lno, P_BOTTOM))
return (1);
} else
if (vs_sm_scroll(sp, &vp->m_final, sp->t_rows, Z_CARAT))
return (1);
break;
default: /* Put the line at the top for <cr>. */
value = KEY_VAL(sp, vp->character);
if (value != K_CR && value != K_NL) {
v_emsg(sp, vp->kp->usage, VIM_USAGE);
return (1);
}
if (vs_sm_fill(sp, lno, P_TOP))
return (1);
break;
}
return (0);
}
/*
* sscr_getprompt --
* Eat lines printed by the shell until a line with no trailing
* carriage return comes; set the prompt from that line.
*/
static int
sscr_getprompt(SCR *sp)
{
struct timeval tv;
CHAR_T *endp, *p, *t, buf[1024];
SCRIPT *sc;
fd_set fdset;
db_recno_t lline;
size_t llen, len;
e_key_t value;
int nr;
FD_ZERO(&fdset);
endp = buf;
len = sizeof(buf);
/* Wait up to a second for characters to read. */
tv.tv_sec = 5;
tv.tv_usec = 0;
sc = sp->script;
FD_SET(sc->sh_master, &fdset);
switch (select(sc->sh_master + 1, &fdset, NULL, NULL, &tv)) {
case -1: /* Error or interrupt. */
msgq(sp, M_SYSERR, "select");
goto prompterr;
case 0: /* Timeout */
msgq(sp, M_ERR, "Error: timed out");
goto prompterr;
case 1: /* Characters to read. */
break;
}
/* Read the characters. */
more: len = sizeof(buf) - (endp - buf);
switch (nr = read(sc->sh_master, endp, len)) {
case 0: /* EOF. */
msgq(sp, M_ERR, "Error: shell: EOF");
goto prompterr;
case -1: /* Error or interrupt. */
msgq(sp, M_SYSERR, "shell");
goto prompterr;
default:
endp += nr;
break;
}
/* If any complete lines, push them into the file. */
for (p = t = buf; p < endp; ++p) {
value = KEY_VAL(sp, *p);
if (value == K_CR || value == K_NL) {
if (db_last(sp, &lline) ||
db_append(sp, 0, lline, t, p - t))
goto prompterr;
t = p + 1;
}
}
if (p > buf) {
MEMMOVE(buf, t, endp - t);
endp = buf + (endp - t);
}
if (endp == buf)
goto more;
/* Wait up 1/10 of a second to make sure that we got it all. */
tv.tv_sec = 0;
tv.tv_usec = 100000;
switch (select(sc->sh_master + 1, &fdset, NULL, NULL, &tv)) {
case -1: /* Error or interrupt. */
msgq(sp, M_SYSERR, "select");
goto prompterr;
case 0: /* Timeout */
break;
case 1: /* Characters to read. */
goto more;
}
/* Timed out, so theoretically we have a prompt. */
llen = endp - buf;
endp = buf;
/* Append the line into the file. */
if (db_last(sp, &lline) || db_append(sp, 0, lline, buf, llen)) {
prompterr: sscr_end(sp);
return (1);
}
return (sscr_setprompt(sp, buf, llen));
}