To compile this driver as modules, choose M here: the
modules will be called pcmcia_core and ds.
+config PCMCIA_DEBUG
+ bool "Enable PCMCIA debugging"
+ depends on PCMCIA != n
+ help
+ Say Y here to enable PCMCIA subsystem debugging. You
+ will need to choose the debugging level either via the
+ kernel command line, or module options depending whether
+ you build the PCMCIA as modules.
+
+ The kernel command line options are:
+ pcmcia_core.pc_debug=N
+ ds.pc_debug=N
+ sa11xx_core.pc_debug=N
+
+ The module option is called pc_debug=N
+
+ In all the above examples, N is the debugging verbosity
+ level.
+
config YENTA
tristate "CardBus yenta-compatible bridge support"
depends on PCMCIA && PCI
# Makefile for the kernel pcmcia subsystem (c/o David Hinds)
#
+ifeq ($(CONFIG_PCMCIA_DEBUG),y)
+EXTRA_CFLAGS += -DDEBUG
+endif
+
obj-$(CONFIG_PCMCIA) += pcmcia_core.o ds.o
obj-$(CONFIG_YENTA) += yenta_socket.o
*
*/
#include <linux/module.h>
+#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/config.h>
#include <linux/delay.h>
#include <asm/au1000.h>
#include <asm/au1000_pcmcia.h>
-#ifdef PCMCIA_DEBUG
+#ifdef DEBUG
static int pc_debug;
+
+module_param(pc_debug, int, 0644);
+
+#define debug(lvl,fmt) do { \
+ if (pc_debug > (lvl)) \
+ printk(KERN_DEBUG fmt); \
+} while (0)
+#else
+#define debug(lvl,fmt) do { } while (0)
#endif
MODULE_LICENSE("GPL");
*/
au1000_pcmcia_poll_event(0);
- DEBUG(1, "au1000: initialization complete\n");
+ debug(1, "au1000: initialization complete\n");
return 0;
} /* au1000_pcmcia_driver_init() */
if (pcmcia_socket[i].virt_io)
iounmap((void *)pcmcia_socket[i].virt_io);
}
- DEBUG(1, "au1000: shutdown complete\n");
+ debug(1, "au1000: shutdown complete\n");
}
module_exit(au1000_pcmcia_driver_shutdown);
unsigned int events=0;
if(state->detect!=prev_state->detect){
- DEBUG(2, "%s(): card detect value %u\n",
+ debug(2, "%s(): card detect value %u\n",
__FUNCTION__, state->detect);
events |= mask&SS_DETECT;
}
if(state->ready!=prev_state->ready){
- DEBUG(2, "%s(): card ready value %u\n",
+ debug(2, "%s(): card ready value %u\n",
__FUNCTION__, state->ready);
events |= mask&((flags&SS_IOCARD)?0:SS_READY);
}
*status|=state.vs_Xv?SS_XVCARD:0;
- DEBUG(2, "\tstatus: %s%s%s%s%s%s%s%s\n",
+ debug(2, "\tstatus: %s%s%s%s%s%s%s%s\n",
(*status&SS_DETECT)?"DETECT ":"",
(*status&SS_READY)?"READY ":"",
(*status&SS_BATDEAD)?"BATDEAD ":"",
{
struct pcmcia_configure configure;
- DEBUG(2, "\tmask: %s%s%s%s%s%s\n\tflags: %s%s%s%s%s%s\n"
+ debug(2, "\tmask: %s%s%s%s%s%s\n\tflags: %s%s%s%s%s%s\n"
"\tVcc %d Vpp %d irq %d\n",
(state->csc_mask==0)?"<NONE>":"",
(state->csc_mask&SS_DETECT)?"DETECT ":"",
static int
au1000_pcmcia_get_io_map(unsigned int sock, struct pccard_io_map *map)
{
- DEBUG(1, "au1000_pcmcia_get_io_map: sock %d\n", sock);
+ debug(1, "au1000_pcmcia_get_io_map: sock %d\n", sock);
if(map->map>=MAX_IO_WIN){
printk(KERN_ERR "%s(): map (%d) out of range\n",
__FUNCTION__, map->map);
map->start=pcmcia_socket[sock].virt_io;
map->stop=map->start+(map->stop-start);
pcmcia_socket[sock].io_map[map->map]=*map;
- DEBUG(3, "set_io_map %d start %x stop %x\n",
+ debug(3, "set_io_map %d start %x stop %x\n",
map->map, map->start, map->stop);
return 0;
map->sys_stop=map->sys_start+(map->sys_stop-start);
pcmcia_socket[sock].mem_map[map->map]=*map;
spin_unlock_irqrestore(&pcmcia_lock, flags);
- DEBUG(3, "set_mem_map %d start %x stop %x card_start %x\n",
+ debug(3, "set_mem_map %d start %x stop %x card_start %x\n",
map->map, map->sys_start, map->sys_stop,
map->card_start);
return 0;
#include <asm/au1000.h>
#include <asm/au1000_pcmcia.h>
+#define debug(fmt, arg...) do { } while (0)
+
#ifdef CONFIG_MIPS_PB1000
#include <asm/pb1000.h>
#define PCMCIA_IRQ AU1000_GPIO_15
}
pcr &= ~PCR_SLOT_0_RST;
- DEBUG(KERN_INFO "Vcc %dV Vpp %dV, pcr %x\n",
+ debug("Vcc %dV Vpp %dV, pcr %x\n",
configure->vcc, configure->vpp, pcr);
switch(configure->vcc){
case 0: /* Vcc 0 */
pcr = au_readw(PB1100_MEM_PCMCIA) & ~0xf;
- DEBUG(KERN_INFO "Vcc %dV Vpp %dV, pcr %x, reset %d\n",
+ debug("Vcc %dV Vpp %dV, pcr %x, reset %d\n",
configure->vcc, configure->vpp, pcr, configure->reset);
#include <pcmcia/cistpl.h>
#include "cs_internal.h"
+static void retry_erase_list(erase_busy_t *list, u_int cause);
+
/*======================================================================
This function handles submitting an MTD request, and retrying
======================================================================*/
-static void insert_queue(erase_busy_t *head, erase_busy_t *entry)
+static void insert_queue(struct pcmcia_socket *s, erase_busy_t *head, erase_busy_t *entry)
{
- DEBUG(2, "cs: adding 0x%p to queue 0x%p\n", entry, head);
+ cs_dbg(s, 2, "adding 0x%p to queue 0x%p\n", entry, head);
entry->next = head;
entry->prev = head->prev;
head->prev->next = entry;
head->prev = entry;
}
-static void remove_queue(erase_busy_t *entry)
+static void remove_queue(struct pcmcia_socket *s, erase_busy_t *entry)
{
- DEBUG(2, "cs: unqueueing 0x%p\n", entry);
+ cs_dbg(s, 2, "unqueueing 0x%p\n", entry);
entry->next->prev = entry->prev;
entry->prev->next = entry->next;
}
struct pcmcia_socket *s;
int ret;
- DEBUG(2, "cs: trying erase request 0x%p...\n", busy);
+ mtd = erase->Handle->mtd;
+ s = SOCKET(mtd);
+
+ cs_dbg(s, 2, "trying erase request 0x%p...\n", busy);
if (busy->next)
- remove_queue(busy);
+ remove_queue(s, busy);
req.Function = MTD_REQ_ERASE | cause;
req.TransferLength = erase->Size;
req.DestCardOffset = erase->Offset + erase->Handle->info.CardOffset;
req.MediaID = erase->Handle->MediaID;
- mtd = erase->Handle->mtd;
- s = SOCKET(mtd);
mtd->event_callback_args.mtdrequest = &req;
ret = EVENT(mtd, CS_EVENT_MTD_REQUEST, CS_EVENT_PRI_LOW);
if (ret == CS_BUSY) {
- DEBUG(2, " Status = %d, requeueing.\n", req.Status);
+ cs_dbg(s, 2, " Status = %d, requeueing.\n", req.Status);
switch (req.Status) {
case MTD_WAITREQ:
case MTD_WAITPOWER:
- insert_queue(&mtd->erase_busy, busy);
+ insert_queue(s, &mtd->erase_busy, busy);
break;
case MTD_WAITTIMER:
case MTD_WAITRDY:
if (req.Status == MTD_WAITRDY)
- insert_queue(&s->erase_busy, busy);
+ insert_queue(s, &s->erase_busy, busy);
mod_timer(&busy->timeout, jiffies + req.Timeout*HZ/1000);
break;
}
} else {
/* update erase queue status */
- DEBUG(2, " Ret = %d\n", ret);
+ cs_dbg(s, 2, " Ret = %d\n", ret);
switch (ret) {
case CS_SUCCESS:
erase->State = ERASE_PASSED; break;
}
} /* retry_erase */
-void retry_erase_list(erase_busy_t *list, u_int cause)
+static void retry_erase_list(erase_busy_t *list, u_int cause)
{
erase_busy_t tmp = *list;
- DEBUG(2, "cs: rescanning erase queue list 0x%p\n", list);
+ cs_dbg(SOCKET(list->client), 2, "rescanning erase queue list 0x%p\n", list);
if (list->next == list)
return;
/* First, truncate the original list */
static void handle_erase_timeout(u_long arg)
{
- DEBUG(0, "cs: erase timeout for entry 0x%lx\n", arg);
- retry_erase((erase_busy_t *)arg, MTD_REQ_TIMEOUT);
+ erase_busy_t *busy = (erase_busy_t *)arg;
+ cs_dbg(SOCKET(busy->client), 0, "erase timeout for entry 0x%lx\n", arg);
+ retry_erase(busy, MTD_REQ_TIMEOUT);
}
static void setup_erase_request(client_handle_t handle, eraseq_entry_t *erase)
cistpl_device_geo_t geo;
memory_handle_t r;
- DEBUG(1, "cs: setup_regions(0x%p, %d, 0x%p)\n",
- handle, attr, list);
+ cs_dbg(SOCKET(handle), 1, "setup_regions(0x%p, %d, 0x%p)\n",
+ handle, attr, list);
code = (attr) ? CISTPL_DEVICE_A : CISTPL_DEVICE;
if (read_tuple(handle, code, &device) != CS_SUCCESS)
code = (attr) ? CISTPL_JEDEC_A : CISTPL_JEDEC_C;
has_jedec = (read_tuple(handle, code, &jedec) == CS_SUCCESS);
if (has_jedec && (device.ndev != jedec.nid)) {
-#ifdef PCMCIA_DEBUG
- printk(KERN_DEBUG "cs: Device info does not match JEDEC info.\n");
-#endif
+ cs_dbg(SOCKET(handle), 0, "Device info does not match JEDEC info.\n");
has_jedec = 0;
}
code = (attr) ? CISTPL_DEVICE_GEO_A : CISTPL_DEVICE_GEO;
has_geo = (read_tuple(handle, code, &geo) == CS_SUCCESS);
if (has_geo && (device.ndev != geo.ngeo)) {
-#ifdef PCMCIA_DEBUG
- printk(KERN_DEBUG "cs: Device info does not match geometry tuple.\n");
-#endif
+ cs_dbg(SOCKET(handle), 0, "Device info does not match geometry tuple.\n");
has_geo = 0;
}
list = s->a_region;
else
list = s->c_region;
- DEBUG(1, "cs: register_mtd(0x%p, '%s', 0x%x)\n",
+ cs_dbg(s, 1, "register_mtd(0x%p, '%s', 0x%x)\n",
handle, handle->dev_info, reg->Offset);
while (list) {
if (list->info.CardOffset == reg->Offset) break;
}
if (region && region->mtd) {
*mh = region;
- DEBUG(1, "cs: open_memory(0x%p, 0x%x) = 0x%p\n",
- handle, open->Offset, region);
+ cs_dbg(s, 1, "open_memory(0x%p, 0x%x) = 0x%p\n",
+ handle, open->Offset, region);
return CS_SUCCESS;
} else
return CS_BAD_OFFSET;
int pcmcia_close_memory(memory_handle_t handle)
{
- DEBUG(1, "cs: close_memory(0x%p)\n", handle);
+ cs_dbg(SOCKET(handle->mtd), 1, "cs: close_memory(0x%p)\n", handle);
if (CHECK_REGION(handle))
return CS_BAD_HANDLE;
return CS_SUCCESS;
#include <pcmcia/cistpl.h>
#include "cs_internal.h"
-#ifdef PCMCIA_DEBUG
-static int pc_debug = PCMCIA_DEBUG;
-#endif
-
/*====================================================================*/
#define FIND_FIRST_BIT(n) ((n) - ((n) & ((n)-1)))
static void cb_release_cis_mem(struct pcmcia_socket * s)
{
if (s->cb_cis_virt) {
- DEBUG(1, "cs: cb_release_cis_mem()\n");
+ cs_dbg(s, 1, "cb_release_cis_mem()\n");
iounmap(s->cb_cis_virt);
s->cb_cis_virt = NULL;
s->cb_cis_res = 0;
struct pci_dev *dev;
struct resource *res;
- DEBUG(3, "cs: read_cb_mem(%d, %#x, %u)\n", space, addr, len);
+ cs_dbg(s, 3, "read_cb_mem(%d, %#x, %u)\n", space, addr, len);
dev = pci_find_slot(s->cb_dev->subordinate->number, 0);
if (!dev)
{
u_char *sys, *end, *buf = ptr;
- DEBUG(3, "cs: read_cis_mem(%d, %#x, %u)\n", attr, addr, len);
+ cs_dbg(s, 3, "read_cis_mem(%d, %#x, %u)\n", attr, addr, len);
if (attr & IS_INDIRECT) {
/* Indirect accesses use a bunch of special registers at fixed
addr = 0;
}
}
- DEBUG(3, "cs: %#2.2x %#2.2x %#2.2x %#2.2x ...\n",
+ cs_dbg(s, 3, " %#2.2x %#2.2x %#2.2x %#2.2x ...\n",
*(u_char *)(ptr+0), *(u_char *)(ptr+1),
*(u_char *)(ptr+2), *(u_char *)(ptr+3));
return 0;
{
u_char *sys, *end, *buf = ptr;
- DEBUG(3, "cs: write_cis_mem(%d, %#x, %u)\n", attr, addr, len);
+ cs_dbg(s, 3, "write_cis_mem(%d, %#x, %u)\n", attr, addr, len);
if (attr & IS_INDIRECT) {
/* Indirect accesses use a bunch of special registers at fixed
ofs += link[1] + 2;
}
if (i == MAX_TUPLES) {
- DEBUG(1, "cs: overrun in pcmcia_get_next_tuple for socket %d\n",
- handle->Socket);
+ cs_dbg(s, 1, "cs: overrun in pcmcia_get_next_tuple\n");
return CS_NO_MORE_ITEMS;
}
======================================================================*/
#include <linux/module.h>
+#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/config.h>
/* Access speed for IO windows */
INT_MODULE_PARM(io_speed, 0); /* ns */
-#ifdef PCMCIA_DEBUG
-INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
-static const char *version =
-"cs.c 1.279 2001/10/13 00:08:28 (David Hinds)";
+#ifdef DEBUG
+static int pc_debug;
+
+module_param(pc_debug, int, 0644);
+
+int cs_debug_level(int level)
+{
+ return pc_debug > level;
+}
#endif
-
+
/*====================================================================*/
socket_state_t dead_socket = {
if (!socket || !socket->ops || !socket->dev.dev)
return -EINVAL;
- DEBUG(0, "cs: pcmcia_register_socket(0x%p)\n", socket->ops);
+ cs_dbg(socket, 0, "pcmcia_register_socket(0x%p)\n", socket->ops);
/* try to obtain a socket number [yes, it gets ugly if we
* register more than 2^sizeof(unsigned int) pcmcia
if (!socket)
return;
- DEBUG(0, "cs: pcmcia_unregister_socket(0x%p)\n", socket->ops);
+ cs_dbg(socket, 0, "pcmcia_unregister_socket(0x%p)\n", socket->ops);
if (socket->thread) {
init_completion(&socket->thread_done);
{
client_t **c;
- DEBUG(1, "cs: shutdown_socket(%p)\n", s);
+ cs_dbg(s, 1, "shutdown_socket\n");
/* Blank out the socket state */
s->state &= SOCKET_PRESENT|SOCKET_INUSE;
{
client_t *client = s->clients;
int ret;
- DEBUG(1, "cs: send_event(sock %d, event %d, pri %d)\n",
- s->sock, event, priority);
+ cs_dbg(s, 1, "send_event(event %d, pri %d)\n",
+ event, priority);
ret = 0;
if (s->state & SOCKET_CARDBUS)
return 0;
return ret;
} /* send_event */
-static void pcmcia_error(struct pcmcia_socket *skt, const char *fmt, ...)
-{
- static char buf[128];
- va_list ap;
- int len;
-
- va_start(ap, fmt);
- len = vsnprintf(buf, sizeof(buf), fmt, ap);
- va_end(ap);
- buf[len] = '\0';
-
- printk(KERN_ERR "PCMCIA: socket %p: %s", skt, buf);
-}
-
#define cs_to_timeout(cs) (((cs) * HZ + 99) / 100)
static void socket_remove_drivers(struct pcmcia_socket *skt)
{
client_t *client;
+ cs_dbg(skt, 4, "remove_drivers\n");
+
send_event(skt, CS_EVENT_CARD_REMOVAL, CS_EVENT_PRI_HIGH);
for (client = skt->clients; client; client = client->next)
static void socket_shutdown(struct pcmcia_socket *skt)
{
+ cs_dbg(skt, 4, "shutdown\n");
+
socket_remove_drivers(skt);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout(cs_to_timeout(shutdown_delay));
{
int status, i;
+ cs_dbg(skt, 4, "reset\n");
+
skt->socket.flags |= SS_OUTPUT_ENA | SS_RESET;
skt->ops->set_socket(skt, &skt->socket);
udelay((long)reset_time);
schedule_timeout(cs_to_timeout(unreset_check));
}
- pcmcia_error(skt, "time out after reset.\n");
+ cs_err(skt, "time out after reset.\n");
return CS_GENERAL_FAILURE;
}
{
int status, i;
+ cs_dbg(skt, 4, "setup\n");
+
skt->ops->get_status(skt, &status);
if (!(status & SS_DETECT))
return CS_NO_CARD;
}
if (status & SS_PENDING) {
- pcmcia_error(skt, "voltage interrogation timed out.\n");
+ cs_err(skt, "voltage interrogation timed out.\n");
return CS_GENERAL_FAILURE;
}
if (status & SS_CARDBUS) {
skt->state |= SOCKET_CARDBUS;
#ifndef CONFIG_CARDBUS
- pcmcia_error(skt, "cardbus cards are not supported.\n");
+ cs_err(skt, "cardbus cards are not supported.\n");
return CS_BAD_TYPE;
#endif
}
else if (!(status & SS_XVCARD))
skt->socket.Vcc = skt->socket.Vpp = 50;
else {
- pcmcia_error(skt, "unsupported voltage key.\n");
+ cs_err(skt, "unsupported voltage key.\n");
return CS_BAD_TYPE;
}
skt->socket.flags = 0;
skt->ops->get_status(skt, &status);
if (!(status & SS_POWERON)) {
- pcmcia_error(skt, "unable to apply power.\n");
+ cs_err(skt, "unable to apply power.\n");
return CS_BAD_TYPE;
}
{
int ret;
+ cs_dbg(skt, 4, "insert\n");
+
if (!cs_socket_get(skt))
return CS_NO_CARD;
skt->state |= SOCKET_CARDBUS_CONFIG;
}
#endif
+ cs_dbg(skt, 4, "insert done\n");
+
send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
} else {
socket_shutdown(skt);
*/
void pcmcia_parse_events(struct pcmcia_socket *s, u_int events)
{
+ cs_dbg(s, 4, "parse_events: events %08x\n", events);
if (s->thread) {
spin_lock(&s->thread_lock);
s->thread_events |= events;
align = (*base) ? (lines ? 1<<lines : 0) : 1;
if (align && (align < num)) {
if (*base) {
- DEBUG(0, "odd IO request: num %04x align %04x\n",
- num, align);
+ cs_dbg(s, 0, "odd IO request: num %04x align %04x\n",
+ num, align);
align = 0;
} else
while (align && (align < num)) align <<= 1;
}
if (*base & ~(align-1)) {
- DEBUG(0, "odd IO request: base %04x align %04x\n",
- *base, align);
+ cs_dbg(s, 0, "odd IO request: base %04x align %04x\n",
+ *base, align);
align = 0;
}
if ((s->features & SS_CAP_STATIC_MAP) && s->io_offset) {
init_waitqueue_head(&client->mtd_req);
client->next = s->clients;
s->clients = client;
- DEBUG(1, "cs: bind_device(): client 0x%p, sock %p, dev %s\n",
- client, client->Socket, client->dev_info);
+ cs_dbg(s, 1, "bind_device(): client 0x%p, dev %s\n",
+ client, client->dev_info);
return CS_SUCCESS;
} /* bind_device */
return CS_BAD_OFFSET;
strlcpy(region->dev_info, (char *)req->dev_info, DEV_NAME_LEN);
- DEBUG(1, "cs: bind_mtd(): attr 0x%x, offset 0x%x, dev %s\n",
- req->Attributes, req->CardOffset, (char *)req->dev_info);
+ cs_dbg(s, 1, "bind_mtd(): attr 0x%x, offset 0x%x, dev %s\n",
+ req->Attributes, req->CardOffset, (char *)req->dev_info);
return CS_SUCCESS;
} /* bind_mtd */
u_long flags;
int i;
- DEBUG(1, "cs: deregister_client(%p)\n", handle);
if (CHECK_HANDLE(handle))
return CS_BAD_HANDLE;
+
+ s = SOCKET(handle);
+ cs_dbg(s, 1, "deregister_client(%p)\n", handle);
+
if (handle->state &
(CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED))
return CS_IN_USE;
return CS_IN_USE;
/* Disconnect all MTD links */
- s = SOCKET(handle);
if (handle->mtd_count) {
for (region = s->a_region; region; region = region->info.next)
if (region->mtd == handle) region->mtd = NULL;
memset(s->config, 0, sizeof(config_t) * s->functions);
}
- DEBUG(1, "cs: register_client(): client 0x%p, sock %p, dev %s\n",
- client, client->Socket, client->dev_info);
+ cs_dbg(s, 1, "register_client(): client 0x%p, dev %s\n",
+ client, client->dev_info);
if (client->EventMask & CS_EVENT_REGISTRATION_COMPLETE)
EVENT(client, CS_EVENT_REGISTRATION_COMPLETE, CS_EVENT_PRI_LOW);
if (CHECK_HANDLE(handle))
return CS_BAD_HANDLE;
- DEBUG(1, "cs: resetting socket %p\n", handle->Socket);
skt = SOCKET(handle);
+ cs_dbg(skt, 1, "resetting socket\n");
down(&skt->skt_sem);
do {
if (CHECK_HANDLE(handle))
return CS_BAD_HANDLE;
- DEBUG(1, "cs: suspending socket %p\n", handle->Socket);
skt = SOCKET(handle);
+ cs_dbg(skt, 1, "suspending socket\n");
down(&skt->skt_sem);
do {
if (CHECK_HANDLE(handle))
return CS_BAD_HANDLE;
- DEBUG(1, "cs: waking up socket %p\n", handle->Socket);
skt = SOCKET(handle);
+ cs_dbg(skt, 1, "waking up socket\n");
down(&skt->skt_sem);
do {
if (CHECK_HANDLE(handle))
return CS_BAD_HANDLE;
- DEBUG(1, "cs: user eject request on socket %p\n", handle->Socket);
skt = SOCKET(handle);
+ cs_dbg(skt, 1, "user eject request\n");
down(&skt->skt_sem);
do {
if (CHECK_HANDLE(handle))
return CS_BAD_HANDLE;
- DEBUG(1, "cs: user insert request on socket %p\n", handle->Socket);
skt = SOCKET(handle);
+ cs_dbg(skt, 1, "user insert request\n");
down(&skt->skt_sem);
do {
{
printk(KERN_INFO "%s\n", release);
printk(KERN_INFO " %s\n", options);
- DEBUG(0, "%s\n", version);
class_register(&pcmcia_socket_class);
return 0;
int read_tuple(client_handle_t handle, cisdata_t code, void *parse);
/* In bulkmem.c */
-void retry_erase_list(struct erase_busy_t *list, u_int cause);
int get_first_region(client_handle_t handle, region_info_t *rgn);
int get_next_region(client_handle_t handle, region_info_t *rgn);
int register_mtd(client_handle_t handle, mtd_reg_t *reg);
extern struct rw_semaphore pcmcia_socket_list_rwsem;
extern struct list_head pcmcia_socket_list;
-#ifdef PCMCIA_DEBUG
-extern int pc_debug;
-#define DEBUG(n, args...) do { if (pc_debug>(n)) printk(KERN_DEBUG args); } while (0)
+#define cs_socket_name(skt) ((skt)->dev.class_id)
+
+#ifdef DEBUG
+extern int cs_debug_level(int);
+
+#define cs_dbg(skt, lvl, fmt, arg...) do { \
+ if (cs_debug_level(lvl)) \
+ printk(KERN_DEBUG "cs: %s: " fmt, \
+ cs_socket_name(skt) , ## arg); \
+} while (0)
+
#else
-#define DEBUG(n, args...) do { } while (0)
+#define cs_dbg(skt, lvl, fmt, arg...) do { } while (0)
#endif
+#define cs_err(skt, fmt, arg...) \
+ printk(KERN_ERR "cs: %s: " fmt, (skt)->dev.class_id , ## arg)
+
#endif /* _LINUX_CS_INTERNAL_H */
#include <linux/config.h>
#include <linux/module.h>
+#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/major.h>
MODULE_DESCRIPTION("PCMCIA Driver Services");
MODULE_LICENSE("Dual MPL/GPL");
-#define INT_MODULE_PARM(n, v) static int n = v; MODULE_PARM(n, "i")
+#ifdef DEBUG
+static int pc_debug;
-#ifdef PCMCIA_DEBUG
-INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
-#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
+module_param(pc_debug, int, 0644);
+
+#define ds_dbg(lvl, fmt, arg...) do { \
+ if (pc_debug > (lvl)) \
+ printk(KERN_DEBUG "ds: " fmt , ## arg); \
+} while (0)
#else
-#define DEBUG(n, args...)
+#define ds_dbg(lvl, fmt, arg...) do { } while (0)
#endif
/*====================================================================*/
{
struct pcmcia_bus_socket *s;
- DEBUG(1, "ds: ds_event(0x%06x, %d, 0x%p)\n",
+ ds_dbg(1, "ds_event(0x%06x, %d, 0x%p)\n",
event, priority, args->client_handle);
s = args->client_data;
if (!s)
return -EINVAL;
- DEBUG(2, "bind_request(%d, '%s')\n", s->parent->sock,
+ ds_dbg(2, "bind_request(%d, '%s')\n", s->parent->sock,
(char *)bind_info->dev_info);
driver = get_pcmcia_driver(&bind_info->dev_info);
if (!driver)
{
socket_bind_t **b, *c;
- DEBUG(2, "unbind_request(%d, '%s')\n", s->parent->sock,
+ ds_dbg(2, "unbind_request(%d, '%s')\n", s->parent->sock,
(char *)bind_info->dev_info);
for (b = &s->bind; *b; b = &(*b)->next)
if ((strcmp((char *)(*b)->driver->drv.name,
struct pcmcia_bus_socket *s;
user_info_t *user;
- DEBUG(0, "ds_open(socket %d)\n", i);
+ ds_dbg(0, "ds_open(socket %d)\n", i);
s = pcmcia_get_bus_socket(i);
if (!s)
struct pcmcia_bus_socket *s;
user_info_t *user, **link;
- DEBUG(0, "ds_release(socket %d)\n", iminor(inode));
+ ds_dbg(0, "ds_release(socket %d)\n", iminor(inode));
user = file->private_data;
if (CHECK_USER(user))
user_info_t *user;
int ret;
- DEBUG(2, "ds_read(socket %d)\n", iminor(inode));
+ ds_dbg(2, "ds_read(socket %d)\n", iminor(file->f_dentry->d_inode));
if (count < 4)
return -EINVAL;
struct pcmcia_bus_socket *s;
user_info_t *user;
- DEBUG(2, "ds_write(socket %d)\n", iminor(inode));
+ ds_dbg(2, "ds_write(socket %d)\n", iminor(file->f_dentry->d_inode));
if (count != 4)
return -EINVAL;
struct pcmcia_bus_socket *s;
user_info_t *user;
- DEBUG(2, "ds_poll(socket %d)\n", iminor(inode));
+ ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_dentry->d_inode));
user = file->private_data;
if (CHECK_USER(user))
ds_ioctl_arg_t buf;
user_info_t *user;
- DEBUG(2, "ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);
+ ds_dbg(2, "ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);
user = file->private_data;
if (CHECK_USER(user))
if (cmd & IOC_IN) {
err = verify_area(VERIFY_READ, (char *)arg, size);
if (err) {
- DEBUG(3, "ds_ioctl(): verify_read = %d\n", err);
+ ds_dbg(3, "ds_ioctl(): verify_read = %d\n", err);
return err;
}
}
if (cmd & IOC_OUT) {
err = verify_area(VERIFY_WRITE, (char *)arg, size);
if (err) {
- DEBUG(3, "ds_ioctl(): verify_write = %d\n", err);
+ ds_dbg(3, "ds_ioctl(): verify_write = %d\n", err);
return err;
}
}
}
if ((err == 0) && (ret != CS_SUCCESS)) {
- DEBUG(2, "ds_ioctl: ret = %d\n", ret);
+ ds_dbg(2, "ds_ioctl: ret = %d\n", ret);
switch (ret) {
case CS_BAD_SOCKET: case CS_NO_CARD:
err = -ENODEV; break;
======================================================================*/
#include <linux/module.h>
+#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/config.h>
#include <linux/types.h>
#include "ricoh.h"
#include "o2micro.h"
-#ifdef PCMCIA_DEBUG
-static int pc_debug = PCMCIA_DEBUG;
-MODULE_PARM(pc_debug, "i");
-#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
+#ifdef DEBUG
static const char *version =
"i82365.c 1.265 1999/11/10 18:36:21 (David Hinds)";
+
+static int pc_debug;
+
+module_param(pc_debug, int, 0644);
+
+#define debug(lvl, fmt, arg...) do { \
+ if (pc_debug > (lvl)) \
+ printk(KERN_DEBUG "i82365: " fmt , ## arg); \
+} while (0)
#else
-#define DEBUG(n, args...) do { } while (0)
+#define debug(lvl, fmt, arg...) do { } while (0)
#endif
static irqreturn_t i365_count_irq(int, void *, struct pt_regs *);
{
i365_get(irq_sock, I365_CSC);
irq_hits++;
- DEBUG(2, "-> hit on irq %d\n", irq);
+ debug(2, "-> hit on irq %d\n", irq);
return IRQ_HANDLED;
}
static u_int __init test_irq(u_short sock, int irq)
{
- DEBUG(2, " testing ISA irq %d\n", irq);
+ debug(2, " testing ISA irq %d\n", irq);
if (request_irq(irq, i365_count_irq, 0, "scan", i365_count_irq) != 0)
return 1;
irq_hits = 0; irq_sock = sock;
schedule_timeout(HZ/100);
if (irq_hits) {
free_irq(irq, i365_count_irq);
- DEBUG(2, " spurious hit!\n");
+ debug(2, " spurious hit!\n");
return 1;
}
/* mask all interrupts */
i365_set(sock, I365_CSCINT, 0);
- DEBUG(2, " hits = %d\n", irq_hits);
+ debug(2, " hits = %d\n", irq_hits);
return (irq_hits != 1);
}
u_long flags = 0;
int handled = 0;
- DEBUG(4, "i82365: pcic_interrupt(%d)\n", irq);
+ debug(4, "pcic_interrupt(%d)\n", irq);
for (j = 0; j < 20; j++) {
active = 0;
events |= (csc & I365_CSC_READY) ? SS_READY : 0;
}
ISA_UNLOCK(i, flags);
- DEBUG(2, "i82365: socket %d event 0x%02x\n", i, events);
+ debug(2, "socket %d event 0x%02x\n", i, events);
if (events)
pcmcia_parse_events(&socket[i].socket, events);
if (j == 20)
printk(KERN_NOTICE "i82365: infinite loop in interrupt handler\n");
- DEBUG(4, "i82365: interrupt done\n");
+ debug(4, "interrupt done\n");
return IRQ_RETVAL(handled);
} /* pcic_interrupt */
}
}
- DEBUG(1, "i82365: GetStatus(%d) = %#4.4x\n", sock, *value);
+ debug(1, "GetStatus(%d) = %#4.4x\n", sock, *value);
return 0;
} /* i365_get_status */
state->csc_mask |= (reg & I365_CSC_READY) ? SS_READY : 0;
}
- DEBUG(1, "i82365: GetSocket(%d) = flags %#3.3x, Vcc %d, Vpp %d, "
+ debug(1, "GetSocket(%d) = flags %#3.3x, Vcc %d, Vpp %d, "
"io_irq %d, csc_mask %#2.2x\n", sock, state->flags,
state->Vcc, state->Vpp, state->io_irq, state->csc_mask);
return 0;
struct i82365_socket *t = &socket[sock];
u_char reg;
- DEBUG(1, "i82365: SetSocket(%d, flags %#3.3x, Vcc %d, Vpp %d, "
+ debug(1, "SetSocket(%d, flags %#3.3x, Vcc %d, Vpp %d, "
"io_irq %d, csc_mask %#2.2x)\n", sock, state->flags,
state->Vcc, state->Vpp, state->io_irq, state->csc_mask);
{
u_char map, ioctl;
- DEBUG(1, "i82365: SetIOMap(%d, %d, %#2.2x, %d ns, "
+ debug(1, "SetIOMap(%d, %d, %#2.2x, %d ns, "
"%#4.4x-%#4.4x)\n", sock, io->map, io->flags,
io->speed, io->start, io->stop);
map = io->map;
u_short base, i;
u_char map;
- DEBUG(1, "i82365: SetMemMap(%d, %d, %#2.2x, %d ns, %#5.5lx-%#5.5"
+ debug(1, "SetMemMap(%d, %d, %#2.2x, %d ns, %#5.5lx-%#5.5"
"lx, %#5.5x)\n", sock, mem->map, mem->flags, mem->speed,
mem->sys_start, mem->sys_stop, mem->card_start);
*/
#include <linux/module.h>
+#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/config.h>
#include <linux/cpufreq.h>
#include "sa11xx_core.h"
#include "sa1100.h"
-#ifdef PCMCIA_DEBUG
+#ifdef DEBUG
static int pc_debug;
+
+module_param(pc_debug, int, 0644);
+
+#define debug(skt, lvl, fmt, arg...) do { \
+ if (pc_debug > (lvl)) \
+ printk(KERN_DEBUG "skt%u: %s: " fmt, \
+ (skt)->nr, __func__ , ## arg); \
+} while (0)
+
+#else
+#define debug(skt, lvl, fmt, arg...) do { } while (0)
#endif
#define to_sa1100_socket(x) container_of(x, struct sa1100_pcmcia_socket, socket)
local_irq_restore(flags);
- DEBUG(4, "%s(): sock %u FAST %X BSM %X BSA %X BSIO %X\n",
- __FUNCTION__, skt->nr, MECR_FAST_GET(mecr, skt->nr),
+ debug(skt, 2, "FAST %X BSM %X BSA %X BSIO %X\n",
+ MECR_FAST_GET(mecr, skt->nr),
MECR_BSM_GET(mecr, skt->nr), MECR_BSA_GET(mecr, skt->nr),
MECR_BSIO_GET(mecr, skt->nr));
{
struct sa1100_pcmcia_socket *skt = to_sa1100_socket(sock);
- DEBUG(2, "%s(): initializing socket %u\n", __FUNCTION__, skt->nr);
+ debug(skt, 2, "initializing socket\n");
skt->ops->socket_init(skt);
return 0;
struct sa1100_pcmcia_socket *skt = to_sa1100_socket(sock);
int ret;
- DEBUG(2, "%s(): suspending socket %u\n", __FUNCTION__, skt->nr);
+ debug(skt, 2, "suspending socket\n");
ret = sa1100_pcmcia_config_skt(skt, &dead_socket);
if (ret == 0)
{
unsigned int events;
- DEBUG(4, "%s(): entering PCMCIA monitoring thread\n", __FUNCTION__);
+ debug(skt, 4, "entering PCMCIA monitoring thread\n");
do {
unsigned int status;
skt->status = status;
spin_unlock_irqrestore(&status_lock, flags);
- DEBUG(2, "events: %s%s%s%s%s%s\n",
+ debug(skt, 4, "events: %s%s%s%s%s%s\n",
events == 0 ? "<NONE>" : "",
events & SS_DETECT ? "DETECT " : "",
events & SS_READY ? "READY " : "",
static void sa1100_pcmcia_poll_event(unsigned long dummy)
{
struct sa1100_pcmcia_socket *skt = (struct sa1100_pcmcia_socket *)dummy;
- DEBUG(4, "%s(): polling for events\n", __FUNCTION__);
+ debug(skt, 4, "polling for events\n");
mod_timer(&skt->poll_timer, jiffies + SA1100_PCMCIA_POLL_PERIOD);
{
struct sa1100_pcmcia_socket *skt = dev;
- DEBUG(3, "%s(): servicing IRQ %d\n", __FUNCTION__, irq);
+ debug(skt, 3, "servicing IRQ %d\n", irq);
sa1100_check_status(skt);
{
struct sa1100_pcmcia_socket *skt = to_sa1100_socket(sock);
- DEBUG(2, "%s() for sock %u\n", __FUNCTION__, skt->nr);
+ debug(skt, 2, "\n");
*state = skt->cs_state;
{
struct sa1100_pcmcia_socket *skt = to_sa1100_socket(sock);
- DEBUG(2, "%s() for sock %u\n", __FUNCTION__, skt->nr);
-
- DEBUG(3, "\tmask: %s%s%s%s%s%s\n\tflags: %s%s%s%s%s%s\n",
- (state->csc_mask==0)?"<NONE>":"",
+ debug(skt, 2, "mask: %s%s%s%s%s%sflags: %s%s%s%s%s%sVcc %d Vpp %d irq %d\n",
+ (state->csc_mask==0)?"<NONE> ":"",
(state->csc_mask&SS_DETECT)?"DETECT ":"",
(state->csc_mask&SS_READY)?"READY ":"",
(state->csc_mask&SS_BATDEAD)?"BATDEAD ":"",
(state->csc_mask&SS_BATWARN)?"BATWARN ":"",
(state->csc_mask&SS_STSCHG)?"STSCHG ":"",
- (state->flags==0)?"<NONE>":"",
+ (state->flags==0)?"<NONE> ":"",
(state->flags&SS_PWR_AUTO)?"PWR_AUTO ":"",
(state->flags&SS_IOCARD)?"IOCARD ":"",
(state->flags&SS_RESET)?"RESET ":"",
(state->flags&SS_SPKR_ENA)?"SPKR_ENA ":"",
- (state->flags&SS_OUTPUT_ENA)?"OUTPUT_ENA ":"");
- DEBUG(3, "\tVcc %d Vpp %d irq %d\n",
+ (state->flags&SS_OUTPUT_ENA)?"OUTPUT_ENA ":"",
state->Vcc, state->Vpp, state->io_irq);
return sa1100_pcmcia_config_skt(skt, state);
struct sa1100_pcmcia_socket *skt = to_sa1100_socket(sock);
unsigned short speed = map->speed;
- DEBUG(2, "%s() for sock %u\n", __FUNCTION__, skt->nr);
-
- DEBUG(3, "\tmap %u speed %u\n\tstart 0x%08x stop 0x%08x\n",
+ debug(skt, 2, "map %u speed %u start 0x%08x stop 0x%08x\n",
map->map, map->speed, map->start, map->stop);
- DEBUG(3, "\tflags: %s%s%s%s%s%s%s%s\n",
+ debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
(map->flags==0)?"<NONE>":"",
(map->flags&MAP_ACTIVE)?"ACTIVE ":"",
(map->flags&MAP_16BIT)?"16BIT ":"",
struct resource *res;
unsigned short speed = map->speed;
- DEBUG(2, "%s() for sock %u\n", __FUNCTION__, skt->nr);
-
- DEBUG(3, "\tmap %u speed %u card_start %08x\n",
+ debug(skt, 2, "map %u speed %u card_start %08x\n",
map->map, map->speed, map->card_start);
- DEBUG(3, "\tflags: %s%s%s%s%s%s%s%s\n",
+ debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
(map->flags==0)?"<NONE>":"",
(map->flags&MAP_ACTIVE)?"ACTIVE ":"",
(map->flags&MAP_16BIT)?"16BIT ":"",
switch (val) {
case CPUFREQ_PRECHANGE:
- if (freqs->new > freqs->old) {
- DEBUG(2, "%s(): new frequency %u.%uMHz > %u.%uMHz, "
- "pre-updating\n", __FUNCTION__,
- freqs->new / 1000, (freqs->new / 100) % 10,
- freqs->old / 1000, (freqs->old / 100) % 10);
+ if (freqs->new > freqs->old)
sa1100_pcmcia_update_mecr(freqs->new);
- }
break;
case CPUFREQ_POSTCHANGE:
- if (freqs->new < freqs->old) {
- DEBUG(2, "%s(): new frequency %u.%uMHz < %u.%uMHz, "
- "post-updating\n", __FUNCTION__,
- freqs->new / 1000, (freqs->new / 100) % 10,
- freqs->old / 1000, (freqs->old / 100) % 10);
+ if (freqs->new < freqs->old)
sa1100_pcmcia_update_mecr(freqs->new);
- }
break;
}
======================================================================*/
#include <linux/module.h>
+#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/fcntl.h>
#include <pcmcia/ss.h>
#include "tcic.h"
-#ifdef PCMCIA_DEBUG
-static int pc_debug = PCMCIA_DEBUG;
+#ifdef DEBUG
+static int pc_debug;
+
+module_param(pc_debug, int, 0644);
MODULE_PARM(pc_debug, "i");
static const char *version =
"tcic.c 1.111 2000/02/15 04:13:12 (David Hinds)";
-#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
+
+#define debug(lvl, fmt, arg...) do { \
+ if (pc_debug > (lvl)) \
+ printk(KERN_DEBUG "tcic: " fmt , ## arg); \
+} while (0)
#else
-#define DEBUG(n, args...)
+#define debug(lvl, fmt, arg...) do { } while (0)
#endif
MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
to map to irq 11, but is coded as 0 or 1 in the irq registers. */
#define TCIC_IRQ(x) ((x) ? (((x) == 11) ? 1 : (x)) : 15)
-#ifdef PCMCIA_DEBUG_X
+#ifdef DEBUG_X
static u_char tcic_getb(u_char reg)
{
u_char val = inb(tcic_base+reg);
static void tcic_setl(u_char reg, u_int data)
{
-#ifdef PCMCIA_DEBUG_X
+#ifdef DEBUG_X
printk(KERN_DEBUG "tcic_setl(%#x, %#lx)\n", tcic_base+reg, data);
#endif
outw(data & 0xffff, tcic_base+reg);
} else
active = 1;
- DEBUG(2, "tcic: tcic_interrupt()\n");
+ debug(2, "tcic_interrupt()\n");
for (i = 0; i < sockets; i++) {
psock = socket_table[i].psock;
}
active = 0;
- DEBUG(2, "tcic: interrupt done\n");
+ debug(2, "interrupt done\n");
return IRQ_HANDLED;
} /* tcic_interrupt */
static void tcic_timer(u_long data)
{
- DEBUG(2, "tcic: tcic_timer()\n");
+ debug(2, "tcic_timer()\n");
tcic_timer_pending = 0;
tcic_interrupt(0, NULL, NULL);
} /* tcic_timer */
reg = tcic_getb(TCIC_PWR);
if (reg & (TCIC_PWR_VCC(psock)|TCIC_PWR_VPP(psock)))
*value |= SS_POWERON;
- DEBUG(1, "tcic: GetStatus(%d) = %#2.2x\n", psock, *value);
+ debug(1, "GetStatus(%d) = %#2.2x\n", psock, *value);
return 0;
} /* tcic_get_status */
state->csc_mask |= (scf2 & TCIC_SCF2_MRDY) ? 0 : SS_READY;
}
- DEBUG(1, "tcic: GetSocket(%d) = flags %#3.3x, Vcc %d, Vpp %d, "
+ debug(1, "GetSocket(%d) = flags %#3.3x, Vcc %d, Vpp %d, "
"io_irq %d, csc_mask %#2.2x\n", psock, state->flags,
state->Vcc, state->Vpp, state->io_irq, state->csc_mask);
return 0;
u_char reg;
u_short scf1, scf2;
- DEBUG(1, "tcic: SetSocket(%d, flags %#3.3x, Vcc %d, Vpp %d, "
+ debug(1, "SetSocket(%d, flags %#3.3x, Vcc %d, Vpp %d, "
"io_irq %d, csc_mask %#2.2x)\n", psock, state->flags,
state->Vcc, state->Vpp, state->io_irq, state->csc_mask);
tcic_setw(TCIC_ADDR+2, (psock << TCIC_SS_SHFT) | TCIC_ADR2_INDREG);
u_int addr;
u_short base, len, ioctl;
- DEBUG(1, "tcic: SetIOMap(%d, %d, %#2.2x, %d ns, "
+ debug(1, "SetIOMap(%d, %d, %#2.2x, %d ns, "
"%#4.4x-%#4.4x)\n", psock, io->map, io->flags,
io->speed, io->start, io->stop);
if ((io->map > 1) || (io->start > 0xffff) || (io->stop > 0xffff) ||
u_short addr, ctl;
u_long base, len, mmap;
- DEBUG(1, "tcic: SetMemMap(%d, %d, %#2.2x, %d ns, "
+ debug(1, "SetMemMap(%d, %d, %#2.2x, %d ns, "
"%#5.5lx-%#5.5lx, %#5.5x)\n", psock, mem->map, mem->flags,
mem->speed, mem->sys_start, mem->sys_stop, mem->card_start);
if ((mem->map > 3) || (mem->card_start > 0x3ffffff) ||
#if 0
-#define DEBUG(x,args...) printk(KERN_DEBUG "%s: " x, __FUNCTION__, ##args)
+#define debug(x,args...) printk(KERN_DEBUG "%s: " x, __func__ , ##args)
#else
-#define DEBUG(x,args...)
+#define debug(x,args...)
#endif
/* Don't ask.. */
static inline u32 cb_readl(struct yenta_socket *socket, unsigned reg)
{
u32 val = readl(socket->base + reg);
- DEBUG("%p %04x %08x\n", socket, reg, val);
+ debug("%p %04x %08x\n", socket, reg, val);
return val;
}
static inline void cb_writel(struct yenta_socket *socket, unsigned reg, u32 val)
{
- DEBUG("%p %04x %08x\n", socket, reg, val);
+ debug("%p %04x %08x\n", socket, reg, val);
writel(val, socket->base + reg);
}
{
u8 val;
pci_read_config_byte(socket->dev, offset, &val);
- DEBUG("%p %04x %02x\n", socket, offset, val);
+ debug("%p %04x %02x\n", socket, offset, val);
return val;
}
{
u16 val;
pci_read_config_word(socket->dev, offset, &val);
- DEBUG("%p %04x %04x\n", socket, offset, val);
+ debug("%p %04x %04x\n", socket, offset, val);
return val;
}
{
u32 val;
pci_read_config_dword(socket->dev, offset, &val);
- DEBUG("%p %04x %08x\n", socket, offset, val);
+ debug("%p %04x %08x\n", socket, offset, val);
return val;
}
static inline void config_writeb(struct yenta_socket *socket, unsigned offset, u8 val)
{
- DEBUG("%p %04x %02x\n", socket, offset, val);
+ debug("%p %04x %02x\n", socket, offset, val);
pci_write_config_byte(socket->dev, offset, val);
}
static inline void config_writew(struct yenta_socket *socket, unsigned offset, u16 val)
{
- DEBUG("%p %04x %04x\n", socket, offset, val);
+ debug("%p %04x %04x\n", socket, offset, val);
pci_write_config_word(socket->dev, offset, val);
}
static inline void config_writel(struct yenta_socket *socket, unsigned offset, u32 val)
{
- DEBUG("%p %04x %08x\n", socket, offset, val);
+ debug("%p %04x %08x\n", socket, offset, val);
pci_write_config_dword(socket->dev, offset, val);
}
static inline u8 exca_readb(struct yenta_socket *socket, unsigned reg)
{
u8 val = readb(socket->base + 0x800 + reg);
- DEBUG("%p %04x %02x\n", socket, reg, val);
+ debug("%p %04x %02x\n", socket, reg, val);
return val;
}
u16 val;
val = readb(socket->base + 0x800 + reg);
val |= readb(socket->base + 0x800 + reg + 1) << 8;
- DEBUG("%p %04x %04x\n", socket, reg, val);
+ debug("%p %04x %04x\n", socket, reg, val);
return val;
}
static inline void exca_writeb(struct yenta_socket *socket, unsigned reg, u8 val)
{
- DEBUG("%p %04x %02x\n", socket, reg, val);
+ debug("%p %04x %02x\n", socket, reg, val);
writeb(val, socket->base + 0x800 + reg);
}
static void exca_writew(struct yenta_socket *socket, unsigned reg, u16 val)
{
- DEBUG("%p %04x %04x\n", socket, reg, val);
+ debug("%p %04x %04x\n", socket, reg, val);
writeb(val, socket->base + 0x800 + reg);
writeb(val >> 8, socket->base + 0x800 + reg + 1);
}
projects / linux / commitdiff