[PATCH] pcmcia: remove client_t usage · tjh.dev/kernel@e12a9a9

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

[PATCH] pcmcia: remove client_t usage

Reduce the occurences of "client_handle_t" which is nothing else than a
pointer to struct pcmcia_device by now.

Signed-off-by: Dominik Brodowski <linux@dominikbrodowski.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

authored by

Dominik Brodowski and committed by

Linus Torvalds 21 years ago e12a9a93 1e212f36

+32 -82

6 changed files

expand all

drivers

pcmcia

cs_internal.h

ds.c

pcmcia_compat.c

pcmcia_resource.c

include

pcmcia

cs_types.h

ds.h

+2 -11

drivers/pcmcia/cs_internal.h

··· 99 99 } 100 100 } 101 101 102 - #define CHECK_HANDLE(h) \ 103 - (((h) == NULL) || ((h)->client_magic != CLIENT_MAGIC)) 104 - 105 102 #define CHECK_SOCKET(s) \ 106 103 (((s) >= sockets) || (socket_table[s]->ops == NULL)) 107 104 108 - #define SOCKET(h) (h->Socket) 109 - #define CONFIG(h) (&SOCKET(h)->config[(h)->Function]) 110 - 111 - #define CHECK_REGION(r) \ 112 - (((r) == NULL) || ((r)->region_magic != REGION_MAGIC)) 113 - 114 - #define CHECK_ERASEQ(q) \ 115 - (((q) == NULL) || ((q)->eraseq_magic != ERASEQ_MAGIC)) 105 + #define SOCKET(h) (h->socket) 106 + #define CONFIG(h) (&SOCKET(h)->config[(h)->func]) 116 107 117 108 /* In cardbus.c */ 118 109 int cb_alloc(struct pcmcia_socket *s);

+13 -22

drivers/pcmcia/ds.c

··· 163 163 int i; 164 164 char *serv; 165 165 166 - if (CHECK_HANDLE(handle)) 166 + if (!handle) 167 167 printk(KERN_NOTICE); 168 168 else { 169 169 struct pcmcia_device *p_dev = handle_to_pdev(handle); ··· 380 380 381 381 if (p_drv->attach) { 382 382 p_dev->instance = p_drv->attach(); 383 - if ((!p_dev->instance) || (p_dev->client.state & CLIENT_UNBOUND)) { 383 + if ((!p_dev->instance) || (p_dev->state & CLIENT_UNBOUND)) { 384 384 printk(KERN_NOTICE "ds: unable to create instance " 385 385 "of '%s'!\n", p_drv->drv.name); 386 386 ret = -EINVAL; ··· 520 520 sprintf (p_dev->dev.bus_id, "%d.%d", p_dev->socket->sock, p_dev->device_no); 521 521 522 522 /* compat */ 523 - p_dev->client.client_magic = CLIENT_MAGIC; 524 - p_dev->client.Socket = s; 525 - p_dev->client.Function = function; 526 - p_dev->client.state = CLIENT_UNBOUND; 523 + p_dev->state = CLIENT_UNBOUND; 527 524 528 525 /* Add to the list in pcmcia_bus_socket */ 529 526 spin_lock_irqsave(&pcmcia_dev_list_lock, flags); ··· 927 930 if (!p_drv) 928 931 return 0; 929 932 930 - if (p_dev->client.state & (CLIENT_UNBOUND|CLIENT_STALE)) 933 + if (p_dev->state & (CLIENT_UNBOUND|CLIENT_STALE)) 931 934 return 0; 932 935 933 936 if (p_drv->event) ··· 996 999 997 1000 int pcmcia_register_client(client_handle_t *handle, client_reg_t *req) 998 1001 { 999 - client_t *client = NULL; 1002 + struct pcmcia_device *client = NULL; 1000 1003 struct pcmcia_socket *s = NULL; 1001 1004 struct pcmcia_device *p_dev = NULL; 1002 1005 struct pcmcia_driver *p_drv = NULL; ··· 1017 1020 p_dev = pcmcia_get_dev(p_dev); 1018 1021 if (!p_dev) 1019 1022 continue; 1020 - if (!(p_dev->client.state & CLIENT_UNBOUND) || 1023 + if (!(p_dev->state & CLIENT_UNBOUND) || 1021 1024 (!p_dev->dev.driver)) { 1022 1025 pcmcia_put_dev(p_dev); 1023 1026 continue; 1024 1027 } 1025 1028 p_drv = to_pcmcia_drv(p_dev->dev.driver); 1026 1029 if (!strncmp(p_drv->drv.name, (char *)req->dev_info, DEV_NAME_LEN)) { 1027 - client = &p_dev->client; 1030 + client = p_dev; 1028 1031 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); 1029 1032 goto found; 1030 1033 } ··· 1040 1043 1041 1044 pcmcia_put_socket(s); /* safe, as we already hold a reference from bind_device */ 1042 1045 1043 - *handle = client; 1044 - client->state &= ~CLIENT_UNBOUND; 1045 - client->Socket = s; 1046 + *handle = p_dev; 1047 + p_dev->state &= ~CLIENT_UNBOUND; 1046 1048 p_dev->event_callback_args = req->event_callback_args; 1047 - p_dev->event_callback_args.client_handle = client; 1049 + p_dev->event_callback_args.client_handle = p_dev; 1048 1050 1049 1051 1050 1052 if (s->state & SOCKET_CARDBUS) 1051 1053 client->state |= CLIENT_CARDBUS; 1052 1054 1053 - if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0) && 1054 - (client->Function != BIND_FN_ALL)) { 1055 + if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0)) { 1055 1056 cistpl_longlink_mfc_t mfc; 1056 - if (pccard_read_tuple(s, client->Function, CISTPL_LONGLINK_MFC, &mfc) 1057 + if (pccard_read_tuple(s, client->func, CISTPL_LONGLINK_MFC, &mfc) 1057 1058 == CS_SUCCESS) 1058 1059 s->functions = mfc.nfn; 1059 1060 else ··· 1103 1108 } 1104 1109 p_dev = list_entry((&s->devices_list)->next, struct pcmcia_device, socket_device_list); 1105 1110 list_del(&p_dev->socket_device_list); 1106 - p_dev->client.state |= CLIENT_STALE; 1111 + p_dev->state |= CLIENT_STALE; 1107 1112 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); 1108 1113 1109 1114 device_unregister(&p_dev->dev); ··· 1118 1123 int i; 1119 1124 struct pcmcia_device *p_dev = handle_to_pdev(handle); 1120 1125 1121 - if (CHECK_HANDLE(handle)) 1122 - return CS_BAD_HANDLE; 1123 - 1124 1126 s = SOCKET(handle); 1125 1127 ds_dbg(1, "deregister_client(%p)\n", handle); 1126 1128 ··· 1128 1136 goto warn_out; 1129 1137 1130 1138 if (handle->state & CLIENT_STALE) { 1131 - handle->client_magic = 0; 1132 1139 handle->state &= ~CLIENT_STALE; 1133 1140 pcmcia_put_dev(p_dev); 1134 1141 } else {

+4 -15

drivers/pcmcia/pcmcia_compat.c

··· 31 31 int pcmcia_get_first_tuple(client_handle_t handle, tuple_t *tuple) 32 32 { 33 33 struct pcmcia_socket *s; 34 - if (CHECK_HANDLE(handle)) 35 - return CS_BAD_HANDLE; 36 34 s = SOCKET(handle); 37 - return pccard_get_first_tuple(s, handle->Function, tuple); 35 + return pccard_get_first_tuple(s, handle->func, tuple); 38 36 } 39 37 EXPORT_SYMBOL(pcmcia_get_first_tuple); 40 38 41 39 int pcmcia_get_next_tuple(client_handle_t handle, tuple_t *tuple) 42 40 { 43 41 struct pcmcia_socket *s; 44 - if (CHECK_HANDLE(handle)) 45 - return CS_BAD_HANDLE; 46 42 s = SOCKET(handle); 47 - return pccard_get_next_tuple(s, handle->Function, tuple); 43 + return pccard_get_next_tuple(s, handle->func, tuple); 48 44 } 49 45 EXPORT_SYMBOL(pcmcia_get_next_tuple); 50 46 51 47 int pcmcia_get_tuple_data(client_handle_t handle, tuple_t *tuple) 52 48 { 53 49 struct pcmcia_socket *s; 54 - if (CHECK_HANDLE(handle)) 55 - return CS_BAD_HANDLE; 56 50 s = SOCKET(handle); 57 51 return pccard_get_tuple_data(s, tuple); 58 52 } ··· 61 67 int pcmcia_validate_cis(client_handle_t handle, cisinfo_t *info) 62 68 { 63 69 struct pcmcia_socket *s; 64 - if (CHECK_HANDLE(handle)) 65 - return CS_BAD_HANDLE; 66 70 s = SOCKET(handle); 67 - return pccard_validate_cis(s, handle->Function, info); 71 + return pccard_validate_cis(s, handle->func, info); 68 72 } 69 73 EXPORT_SYMBOL(pcmcia_validate_cis); 70 74 ··· 70 78 int pcmcia_reset_card(client_handle_t handle, client_req_t *req) 71 79 { 72 80 struct pcmcia_socket *skt; 73 - 74 - if (CHECK_HANDLE(handle)) 75 - return CS_BAD_HANDLE; 81 + 76 82 skt = SOCKET(handle); 77 83 if (!skt) 78 84 return CS_BAD_HANDLE; ··· 78 88 return pccard_reset_card(skt); 79 89 } 80 90 EXPORT_SYMBOL(pcmcia_reset_card); 81 -

+8 -23

drivers/pcmcia/pcmcia_resource.c

··· 206 206 conf_reg_t *reg) 207 207 { 208 208 struct pcmcia_socket *s; 209 - if (CHECK_HANDLE(handle)) 210 - return CS_BAD_HANDLE; 211 209 s = SOCKET(handle); 212 - return pccard_access_configuration_register(s, handle->Function, reg); 210 + return pccard_access_configuration_register(s, handle->func, reg); 213 211 } 214 212 EXPORT_SYMBOL(pcmcia_access_configuration_register); 215 213 ··· 274 276 { 275 277 struct pcmcia_socket *s; 276 278 277 - if ((CHECK_HANDLE(handle)) || !config) 279 + if (!config) 278 280 return CS_BAD_HANDLE; 279 281 s = SOCKET(handle); 280 282 if (!s) 281 283 return CS_BAD_HANDLE; 282 - return pccard_get_configuration_info(s, handle->Function, config); 284 + return pccard_get_configuration_info(s, handle->func, config); 283 285 } 284 286 EXPORT_SYMBOL(pcmcia_get_configuration_info); 285 287 ··· 380 382 int pcmcia_get_status(client_handle_t handle, cs_status_t *status) 381 383 { 382 384 struct pcmcia_socket *s; 383 - if (CHECK_HANDLE(handle)) 384 - return CS_BAD_HANDLE; 385 385 s = SOCKET(handle); 386 - return pccard_get_status(s, handle->Function, status); 386 + return pccard_get_status(s, handle->func, status); 387 387 } 388 388 EXPORT_SYMBOL(pcmcia_get_status); 389 389 ··· 428 432 struct pcmcia_socket *s; 429 433 config_t *c; 430 434 431 - if (CHECK_HANDLE(handle)) 432 - return CS_BAD_HANDLE; 433 435 s = SOCKET(handle); 434 436 c = CONFIG(handle); 435 437 if (!(s->state & SOCKET_PRESENT)) ··· 472 478 struct pcmcia_socket *s; 473 479 int i; 474 480 475 - if (CHECK_HANDLE(handle) || 476 - !(handle->state & CLIENT_CONFIG_LOCKED)) 481 + if (!(handle->state & CLIENT_CONFIG_LOCKED)) 477 482 return CS_BAD_HANDLE; 478 483 handle->state &= ~CLIENT_CONFIG_LOCKED; 479 484 s = SOCKET(handle); ··· 520 527 { 521 528 struct pcmcia_socket *s; 522 529 523 - if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IO_REQ)) 530 + if (!(handle->state & CLIENT_IO_REQ)) 524 531 return CS_BAD_HANDLE; 525 532 handle->state &= ~CLIENT_IO_REQ; 526 533 s = SOCKET(handle); ··· 554 561 int pcmcia_release_irq(client_handle_t handle, irq_req_t *req) 555 562 { 556 563 struct pcmcia_socket *s; 557 - if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IRQ_REQ)) 564 + if (!(handle->state & CLIENT_IRQ_REQ)) 558 565 return CS_BAD_HANDLE; 559 566 handle->state &= ~CLIENT_IRQ_REQ; 560 567 s = SOCKET(handle); ··· 625 632 config_t *c; 626 633 pccard_io_map iomap; 627 634 628 - if (CHECK_HANDLE(handle)) 629 - return CS_BAD_HANDLE; 630 635 s = SOCKET(handle); 631 636 if (!(s->state & SOCKET_PRESENT)) 632 637 return CS_NO_CARD; ··· 753 762 struct pcmcia_socket *s; 754 763 config_t *c; 755 764 756 - if (CHECK_HANDLE(handle)) 757 - return CS_BAD_HANDLE; 758 765 s = SOCKET(handle); 759 766 if (!(s->state & SOCKET_PRESENT)) 760 767 return CS_NO_CARD; ··· 823 834 int ret = CS_IN_USE, irq = 0; 824 835 struct pcmcia_device *p_dev = handle_to_pdev(handle); 825 836 826 - if (CHECK_HANDLE(handle)) 827 - return CS_BAD_HANDLE; 828 837 s = SOCKET(handle); 829 838 if (!(s->state & SOCKET_PRESENT)) 830 839 return CS_NO_CARD; ··· 913 926 u_long align; 914 927 int w; 915 928 916 - if (CHECK_HANDLE(*handle)) 917 - return CS_BAD_HANDLE; 918 - s = (*handle)->Socket; 929 + s = (*handle)->socket; 919 930 if (!(s->state & SOCKET_PRESENT)) 920 931 return CS_NO_CARD; 921 932 if (req->Attributes & (WIN_PAGED | WIN_SHARED))

+2 -2

include/pcmcia/cs_types.h

··· 34 34 typedef u_char cisdata_t; 35 35 typedef u_short page_t; 36 36 37 - struct client_t; 38 - typedef struct client_t *client_handle_t; 37 + struct pcmcia_device; 38 + typedef struct pcmcia_device *client_handle_t; 39 39 40 40 struct window_t; 41 41 typedef struct window_t *window_handle_t;

+3 -9

include/pcmcia/ds.h

··· 162 162 struct soon */ 163 163 dev_link_t *instance; 164 164 event_callback_args_t event_callback_args; 165 - 166 - struct client_t { 167 - u_short client_magic; 168 - struct pcmcia_socket *Socket; 169 - u_char Function; 170 - u_int state; 171 - } client; 165 + u_int state; 172 166 173 167 /* information about this device */ 174 168 u8 has_manf_id:1; ··· 187 193 #define to_pcmcia_dev(n) container_of(n, struct pcmcia_device, dev) 188 194 #define to_pcmcia_drv(n) container_of(n, struct pcmcia_driver, drv) 189 195 190 - #define handle_to_pdev(handle) container_of(handle, struct pcmcia_device, client); 191 - #define handle_to_dev(handle) ((container_of(handle, struct pcmcia_device, client))->dev) 196 + #define handle_to_pdev(handle) (handle) 197 + #define handle_to_dev(handle) (handle->dev) 192 198 193 199 /* error reporting */ 194 200 void cs_error(client_handle_t handle, int func, int ret);