| /shark/trunk/drivers/linuxc26/include/linux/dvb/frontend.h |
|---|
| 0,0 → 1,260 |
| /* |
| * frontend.h |
| * |
| * Copyright (C) 2000 Marcus Metzler <marcus@convergence.de> |
| * Ralph Metzler <ralph@convergence.de> |
| * Holger Waechtler <holger@convergence.de> |
| * Andre Draszik <ad@convergence.de> |
| * for convergence integrated media GmbH |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public License |
| * as published by the Free Software Foundation; either version 2.1 |
| * of the License, or (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| * |
| */ |
| #ifndef _DVBFRONTEND_H_ |
| #define _DVBFRONTEND_H_ |
| #include <asm/types.h> |
| typedef enum fe_type { |
| FE_QPSK, |
| FE_QAM, |
| FE_OFDM |
| } fe_type_t; |
| typedef enum fe_caps { |
| FE_IS_STUPID = 0, |
| FE_CAN_INVERSION_AUTO = 0x1, |
| FE_CAN_FEC_1_2 = 0x2, |
| FE_CAN_FEC_2_3 = 0x4, |
| FE_CAN_FEC_3_4 = 0x8, |
| FE_CAN_FEC_4_5 = 0x10, |
| FE_CAN_FEC_5_6 = 0x20, |
| FE_CAN_FEC_6_7 = 0x40, |
| FE_CAN_FEC_7_8 = 0x80, |
| FE_CAN_FEC_8_9 = 0x100, |
| FE_CAN_FEC_AUTO = 0x200, |
| FE_CAN_QPSK = 0x400, |
| FE_CAN_QAM_16 = 0x800, |
| FE_CAN_QAM_32 = 0x1000, |
| FE_CAN_QAM_64 = 0x2000, |
| FE_CAN_QAM_128 = 0x4000, |
| FE_CAN_QAM_256 = 0x8000, |
| FE_CAN_QAM_AUTO = 0x10000, |
| FE_CAN_TRANSMISSION_MODE_AUTO = 0x20000, |
| FE_CAN_BANDWIDTH_AUTO = 0x40000, |
| FE_CAN_GUARD_INTERVAL_AUTO = 0x80000, |
| FE_CAN_HIERARCHY_AUTO = 0x100000, |
| FE_CAN_RECOVER = 0x20000000, |
| FE_CAN_CLEAN_SETUP = 0x40000000, |
| FE_CAN_MUTE_TS = 0x80000000 |
| } fe_caps_t; |
| struct dvb_frontend_info { |
| char name[128]; |
| fe_type_t type; |
| __u32 frequency_min; |
| __u32 frequency_max; |
| __u32 frequency_stepsize; |
| __u32 frequency_tolerance; |
| __u32 symbol_rate_min; |
| __u32 symbol_rate_max; |
| __u32 symbol_rate_tolerance; /* ppm */ |
| __u32 notifier_delay; /* ms */ |
| fe_caps_t caps; |
| }; |
| /** |
| * Check out the DiSEqC bus spec available on http://www.eutelsat.org/ for |
| * the meaning of this struct... |
| */ |
| struct dvb_diseqc_master_cmd { |
| __u8 msg [6]; /* { framing, address, command, data [3] } */ |
| __u8 msg_len; /* valid values are 3...6 */ |
| }; |
| struct dvb_diseqc_slave_reply { |
| __u8 msg [4]; /* { framing, data [3] } */ |
| __u8 msg_len; /* valid values are 0...4, 0 means no msg */ |
| int timeout; /* return from ioctl after timeout ms with */ |
| }; /* errorcode when no message was received */ |
| typedef enum fe_sec_voltage { |
| SEC_VOLTAGE_13, |
| SEC_VOLTAGE_18, |
| SEC_VOLTAGE_OFF |
| } fe_sec_voltage_t; |
| typedef enum fe_sec_tone_mode { |
| SEC_TONE_ON, |
| SEC_TONE_OFF |
| } fe_sec_tone_mode_t; |
| typedef enum fe_sec_mini_cmd { |
| SEC_MINI_A, |
| SEC_MINI_B |
| } fe_sec_mini_cmd_t; |
| typedef enum fe_status { |
| FE_HAS_SIGNAL = 0x01, /* found something above the noise level */ |
| FE_HAS_CARRIER = 0x02, /* found a DVB signal */ |
| FE_HAS_VITERBI = 0x04, /* FEC is stable */ |
| FE_HAS_SYNC = 0x08, /* found sync bytes */ |
| FE_HAS_LOCK = 0x10, /* everything's working... */ |
| FE_TIMEDOUT = 0x20, /* no lock within the last ~2 seconds */ |
| FE_REINIT = 0x40 /* frontend was reinitialized, */ |
| } fe_status_t; /* application is recommended to reset */ |
| /* DiSEqC, tone and parameters */ |
| typedef enum fe_spectral_inversion { |
| INVERSION_OFF, |
| INVERSION_ON, |
| INVERSION_AUTO |
| } fe_spectral_inversion_t; |
| typedef enum fe_code_rate { |
| FEC_NONE = 0, |
| FEC_1_2, |
| FEC_2_3, |
| FEC_3_4, |
| FEC_4_5, |
| FEC_5_6, |
| FEC_6_7, |
| FEC_7_8, |
| FEC_8_9, |
| FEC_AUTO |
| } fe_code_rate_t; |
| typedef enum fe_modulation { |
| QPSK, |
| QAM_16, |
| QAM_32, |
| QAM_64, |
| QAM_128, |
| QAM_256, |
| QAM_AUTO |
| } fe_modulation_t; |
| typedef enum fe_transmit_mode { |
| TRANSMISSION_MODE_2K, |
| TRANSMISSION_MODE_8K, |
| TRANSMISSION_MODE_AUTO |
| } fe_transmit_mode_t; |
| typedef enum fe_bandwidth { |
| BANDWIDTH_8_MHZ, |
| BANDWIDTH_7_MHZ, |
| BANDWIDTH_6_MHZ, |
| BANDWIDTH_AUTO |
| } fe_bandwidth_t; |
| typedef enum fe_guard_interval { |
| GUARD_INTERVAL_1_32, |
| GUARD_INTERVAL_1_16, |
| GUARD_INTERVAL_1_8, |
| GUARD_INTERVAL_1_4, |
| GUARD_INTERVAL_AUTO |
| } fe_guard_interval_t; |
| typedef enum fe_hierarchy { |
| HIERARCHY_NONE, |
| HIERARCHY_1, |
| HIERARCHY_2, |
| HIERARCHY_4, |
| HIERARCHY_AUTO |
| } fe_hierarchy_t; |
| struct dvb_qpsk_parameters { |
| __u32 symbol_rate; /* symbol rate in Symbols per second */ |
| fe_code_rate_t fec_inner; /* forward error correction (see above) */ |
| }; |
| struct dvb_qam_parameters { |
| __u32 symbol_rate; /* symbol rate in Symbols per second */ |
| fe_code_rate_t fec_inner; /* forward error correction (see above) */ |
| fe_modulation_t modulation; /* modulation type (see above) */ |
| }; |
| struct dvb_ofdm_parameters { |
| fe_bandwidth_t bandwidth; |
| fe_code_rate_t code_rate_HP; /* high priority stream code rate */ |
| fe_code_rate_t code_rate_LP; /* low priority stream code rate */ |
| fe_modulation_t constellation; /* modulation type (see above) */ |
| fe_transmit_mode_t transmission_mode; |
| fe_guard_interval_t guard_interval; |
| fe_hierarchy_t hierarchy_information; |
| }; |
| struct dvb_frontend_parameters { |
| __u32 frequency; /* (absolute) frequency in Hz for QAM/OFDM */ |
| /* intermediate frequency in kHz for QPSK */ |
| fe_spectral_inversion_t inversion; |
| union { |
| struct dvb_qpsk_parameters qpsk; |
| struct dvb_qam_parameters qam; |
| struct dvb_ofdm_parameters ofdm; |
| } u; |
| }; |
| struct dvb_frontend_event { |
| fe_status_t status; |
| struct dvb_frontend_parameters parameters; |
| }; |
| #define FE_GET_INFO _IOR('o', 61, struct dvb_frontend_info) |
| #define FE_DISEQC_RESET_OVERLOAD _IO('o', 62) |
| #define FE_DISEQC_SEND_MASTER_CMD _IOW('o', 63, struct dvb_diseqc_master_cmd) |
| #define FE_DISEQC_RECV_SLAVE_REPLY _IOR('o', 64, struct dvb_diseqc_slave_reply) |
| #define FE_DISEQC_SEND_BURST _IO('o', 65) /* fe_sec_mini_cmd_t */ |
| #define FE_SET_TONE _IO('o', 66) /* fe_sec_tone_mode_t */ |
| #define FE_SET_VOLTAGE _IO('o', 67) /* fe_sec_voltage_t */ |
| #define FE_ENABLE_HIGH_LNB_VOLTAGE _IO('o', 68) /* int */ |
| #define FE_READ_STATUS _IOR('o', 69, fe_status_t) |
| #define FE_READ_BER _IOR('o', 70, __u32) |
| #define FE_READ_SIGNAL_STRENGTH _IOR('o', 71, __u16) |
| #define FE_READ_SNR _IOR('o', 72, __u16) |
| #define FE_READ_UNCORRECTED_BLOCKS _IOR('o', 73, __u32) |
| #define FE_SET_FRONTEND _IOW('o', 76, struct dvb_frontend_parameters) |
| #define FE_GET_FRONTEND _IOR('o', 77, struct dvb_frontend_parameters) |
| #define FE_GET_EVENT _IOR('o', 78, struct dvb_frontend_event) |
| #endif /*_DVBFRONTEND_H_*/ |
| /shark/trunk/drivers/linuxc26/include/linux/dvb/audio.h |
|---|
| 0,0 → 1,125 |
| /* |
| * audio.h |
| * |
| * Copyright (C) 2000 Ralph Metzler <ralph@convergence.de> |
| * & Marcus Metzler <marcus@convergence.de> |
| for convergence integrated media GmbH |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Lesser Public License |
| * as published by the Free Software Foundation; either version 2.1 |
| * of the License, or (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| * |
| */ |
| #ifndef _DVBAUDIO_H_ |
| #define _DVBAUDIO_H_ |
| #ifdef __KERNEL__ |
| #include <linux/types.h> |
| #else |
| #include <stdint.h> |
| #endif |
| typedef enum { |
| AUDIO_SOURCE_DEMUX, /* Select the demux as the main source */ |
| AUDIO_SOURCE_MEMORY /* Select internal memory as the main source */ |
| } audio_stream_source_t; |
| typedef enum { |
| AUDIO_STOPPED, /* Device is stopped */ |
| AUDIO_PLAYING, /* Device is currently playing */ |
| AUDIO_PAUSED /* Device is paused */ |
| } audio_play_state_t; |
| typedef enum { |
| AUDIO_STEREO, |
| AUDIO_MONO_LEFT, |
| AUDIO_MONO_RIGHT |
| } audio_channel_select_t; |
| typedef struct audio_mixer { |
| unsigned int volume_left; |
| unsigned int volume_right; |
| // what else do we need? bass, pass-through, ... |
| } audio_mixer_t; |
| typedef struct audio_status { |
| int AV_sync_state; /* sync audio and video? */ |
| int mute_state; /* audio is muted */ |
| audio_play_state_t play_state; /* current playback state */ |
| audio_stream_source_t stream_source; /* current stream source */ |
| audio_channel_select_t channel_select; /* currently selected channel */ |
| int bypass_mode; /* pass on audio data to */ |
| audio_mixer_t mixer_state; /* current mixer state */ |
| } audio_status_t; /* separate decoder hardware */ |
| typedef |
| struct audio_karaoke{ /* if Vocal1 or Vocal2 are non-zero, they get mixed */ |
| int vocal1; /* into left and right t at 70% each */ |
| int vocal2; /* if both, Vocal1 and Vocal2 are non-zero, Vocal1 gets*/ |
| int melody; /* mixed into the left channel and */ |
| /* Vocal2 into the right channel at 100% each. */ |
| /* if Melody is non-zero, the melody channel gets mixed*/ |
| } audio_karaoke_t; /* into left and right */ |
| typedef uint16_t audio_attributes_t; |
| /* bits: descr. */ |
| /* 15-13 audio coding mode (0=ac3, 2=mpeg1, 3=mpeg2ext, 4=LPCM, 6=DTS, */ |
| /* 12 multichannel extension */ |
| /* 11-10 audio type (0=not spec, 1=language included) */ |
| /* 9- 8 audio application mode (0=not spec, 1=karaoke, 2=surround) */ |
| /* 7- 6 Quantization / DRC (mpeg audio: 1=DRC exists)(lpcm: 0=16bit, */ |
| /* 5- 4 Sample frequency fs (0=48kHz, 1=96kHz) */ |
| /* 2- 0 number of audio channels (n+1 channels) */ |
| /* for GET_CAPABILITIES and SET_FORMAT, the latter should only set one bit */ |
| #define AUDIO_CAP_DTS 1 |
| #define AUDIO_CAP_LPCM 2 |
| #define AUDIO_CAP_MP1 4 |
| #define AUDIO_CAP_MP2 8 |
| #define AUDIO_CAP_MP3 16 |
| #define AUDIO_CAP_AAC 32 |
| #define AUDIO_CAP_OGG 64 |
| #define AUDIO_CAP_SDDS 128 |
| #define AUDIO_CAP_AC3 256 |
| #define AUDIO_STOP _IO('o', 1) |
| #define AUDIO_PLAY _IO('o', 2) |
| #define AUDIO_PAUSE _IO('o', 3) |
| #define AUDIO_CONTINUE _IO('o', 4) |
| #define AUDIO_SELECT_SOURCE _IO('o', 5) |
| #define AUDIO_SET_MUTE _IO('o', 6) |
| #define AUDIO_SET_AV_SYNC _IO('o', 7) |
| #define AUDIO_SET_BYPASS_MODE _IO('o', 8) |
| #define AUDIO_CHANNEL_SELECT _IO('o', 9) |
| #define AUDIO_GET_STATUS _IOR('o', 10, audio_status_t) |
| #define AUDIO_GET_CAPABILITIES _IOR('o', 11, unsigned int) |
| #define AUDIO_CLEAR_BUFFER _IO('o', 12) |
| #define AUDIO_SET_ID _IO('o', 13) |
| #define AUDIO_SET_MIXER _IOW('o', 14, audio_mixer_t) |
| #define AUDIO_SET_STREAMTYPE _IO('o', 15) |
| #define AUDIO_SET_EXT_ID _IO('o', 16) |
| #define AUDIO_SET_ATTRIBUTES _IOW('o', 17, audio_attributes_t) |
| #define AUDIO_SET_KARAOKE _IOW('o', 18, audio_karaoke_t) |
| #endif /* _DVBAUDIO_H_ */ |
| /shark/trunk/drivers/linuxc26/include/linux/dvb/ca.h |
|---|
| 0,0 → 1,91 |
| /* |
| * ca.h |
| * |
| * Copyright (C) 2000 Ralph Metzler <ralph@convergence.de> |
| * & Marcus Metzler <marcus@convergence.de> |
| for convergence integrated media GmbH |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Lesser Public License |
| * as published by the Free Software Foundation; either version 2.1 |
| * of the License, or (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| * |
| */ |
| #ifndef _DVBCA_H_ |
| #define _DVBCA_H_ |
| /* slot interface types and info */ |
| typedef struct ca_slot_info { |
| int num; /* slot number */ |
| int type; /* CA interface this slot supports */ |
| #define CA_CI 1 /* CI high level interface */ |
| #define CA_CI_LINK 2 /* CI link layer level interface */ |
| #define CA_CI_PHYS 4 /* CI physical layer level interface */ |
| #define CA_DESCR 8 /* built-in descrambler */ |
| #define CA_SC 128 /* simple smart card interface */ |
| unsigned int flags; |
| #define CA_CI_MODULE_PRESENT 1 /* module (or card) inserted */ |
| #define CA_CI_MODULE_READY 2 |
| } ca_slot_info_t; |
| /* descrambler types and info */ |
| typedef struct ca_descr_info { |
| unsigned int num; /* number of available descramblers (keys) */ |
| unsigned int type; /* type of supported scrambling system */ |
| #define CA_ECD 1 |
| #define CA_NDS 2 |
| #define CA_DSS 4 |
| } ca_descr_info_t; |
| typedef struct ca_caps { |
| unsigned int slot_num; /* total number of CA card and module slots */ |
| unsigned int slot_type; /* OR of all supported types */ |
| unsigned int descr_num; /* total number of descrambler slots (keys) */ |
| unsigned int descr_type; /* OR of all supported types */ |
| } ca_caps_t; |
| /* a message to/from a CI-CAM */ |
| typedef struct ca_msg { |
| unsigned int index; |
| unsigned int type; |
| unsigned int length; |
| unsigned char msg[256]; |
| } ca_msg_t; |
| typedef struct ca_descr { |
| unsigned int index; |
| unsigned int parity; /* 0 == even, 1 == odd */ |
| unsigned char cw[8]; |
| } ca_descr_t; |
| typedef struct ca_pid { |
| unsigned int pid; |
| int index; /* -1 == disable*/ |
| } ca_pid_t; |
| #define CA_RESET _IO('o', 128) |
| #define CA_GET_CAP _IOR('o', 129, ca_caps_t) |
| #define CA_GET_SLOT_INFO _IOR('o', 130, ca_slot_info_t) |
| #define CA_GET_DESCR_INFO _IOR('o', 131, ca_descr_info_t) |
| #define CA_GET_MSG _IOR('o', 132, ca_msg_t) |
| #define CA_SEND_MSG _IOW('o', 133, ca_msg_t) |
| #define CA_SET_DESCR _IOW('o', 134, ca_descr_t) |
| #define CA_SET_PID _IOW('o', 135, ca_pid_t) |
| #endif |
| /shark/trunk/drivers/linuxc26/include/linux/dvb/version.h |
|---|
| 0,0 → 1,29 |
| /* |
| * version.h |
| * |
| * Copyright (C) 2000 Holger Waechtler <holger@convergence.de> |
| * for convergence integrated media GmbH |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public License |
| * as published by the Free Software Foundation; either version 2.1 |
| * of the License, or (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| * |
| */ |
| #ifndef _DVBVERSION_H_ |
| #define _DVBVERSION_H_ |
| #define DVB_API_VERSION 3 |
| #endif /*_DVBVERSION_H_*/ |
| /shark/trunk/drivers/linuxc26/include/linux/dvb/osd.h |
|---|
| 0,0 → 1,111 |
| /* |
| * osd.h |
| * |
| * Copyright (C) 2001 Ralph Metzler <ralph@convergence.de> |
| * & Marcus Metzler <marcus@convergence.de> |
| for convergence integrated media GmbH |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Lesser Public License |
| * as published by the Free Software Foundation; either version 2.1 |
| * of the License, or (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| * |
| */ |
| #ifndef _DVBOSD_H_ |
| #define _DVBOSD_H_ |
| typedef enum { |
| // All functions return -2 on "not open" |
| OSD_Close=1, // () |
| // Disables OSD and releases the buffers |
| // returns 0 on success |
| OSD_Open, // (x0,y0,x1,y1,BitPerPixel[2/4/8](color&0x0F),mix[0..15](color&0xF0)) |
| // Opens OSD with this size and bit depth |
| // returns 0 on success, -1 on DRAM allocation error, -2 on "already open" |
| OSD_Show, // () |
| // enables OSD mode |
| // returns 0 on success |
| OSD_Hide, // () |
| // disables OSD mode |
| // returns 0 on success |
| OSD_Clear, // () |
| // Sets all pixel to color 0 |
| // returns 0 on success |
| OSD_Fill, // (color) |
| // Sets all pixel to color <col> |
| // returns 0 on success |
| OSD_SetColor, // (color,R{x0},G{y0},B{x1},opacity{y1}) |
| // set palette entry <num> to <r,g,b>, <mix> and <trans> apply |
| // R,G,B: 0..255 |
| // R=Red, G=Green, B=Blue |
| // opacity=0: pixel opacity 0% (only video pixel shows) |
| // opacity=1..254: pixel opacity as specified in header |
| // opacity=255: pixel opacity 100% (only OSD pixel shows) |
| // returns 0 on success, -1 on error |
| OSD_SetPalette, // (firstcolor{color},lastcolor{x0},data) |
| // Set a number of entries in the palette |
| // sets the entries "firstcolor" through "lastcolor" from the array "data" |
| // data has 4 byte for each color: |
| // R,G,B, and a opacity value: 0->transparent, 1..254->mix, 255->pixel |
| OSD_SetTrans, // (transparency{color}) |
| // Sets transparency of mixed pixel (0..15) |
| // returns 0 on success |
| OSD_SetPixel, // (x0,y0,color) |
| // sets pixel <x>,<y> to color number <col> |
| // returns 0 on success, -1 on error |
| OSD_GetPixel, // (x0,y0) |
| // returns color number of pixel <x>,<y>, or -1 |
| OSD_SetRow, // (x0,y0,x1,data) |
| // fills pixels x0,y through x1,y with the content of data[] |
| // returns 0 on success, -1 on clipping all pixel (no pixel drawn) |
| OSD_SetBlock, // (x0,y0,x1,y1,increment{color},data) |
| // fills pixels x0,y0 through x1,y1 with the content of data[] |
| // inc contains the width of one line in the data block, |
| // inc<=0 uses blockwidth as linewidth |
| // returns 0 on success, -1 on clipping all pixel |
| OSD_FillRow, // (x0,y0,x1,color) |
| // fills pixels x0,y through x1,y with the color <col> |
| // returns 0 on success, -1 on clipping all pixel |
| OSD_FillBlock, // (x0,y0,x1,y1,color) |
| // fills pixels x0,y0 through x1,y1 with the color <col> |
| // returns 0 on success, -1 on clipping all pixel |
| OSD_Line, // (x0,y0,x1,y1,color) |
| // draw a line from x0,y0 to x1,y1 with the color <col> |
| // returns 0 on success |
| OSD_Query, // (x0,y0,x1,y1,xasp{color}}), yasp=11 |
| // fills parameters with the picture dimensions and the pixel aspect ratio |
| // returns 0 on success |
| OSD_Test, // () |
| // draws a test picture. for debugging purposes only |
| // returns 0 on success |
| // TODO: remove "test" in final version |
| OSD_Text, // (x0,y0,size,color,text) |
| OSD_SetWindow, // (x0) set window with number 0<x0<8 as current |
| OSD_MoveWindow, // move current window to (x0, y0) |
| } OSD_Command; |
| typedef struct osd_cmd_s { |
| OSD_Command cmd; |
| int x0; |
| int y0; |
| int x1; |
| int y1; |
| int color; |
| void *data; |
| } osd_cmd_t; |
| #define OSD_SEND_CMD _IOW('o', 160, osd_cmd_t) |
| #endif |
| /shark/trunk/drivers/linuxc26/include/linux/dvb/net.h |
|---|
| 0,0 → 1,41 |
| /* |
| * net.h |
| * |
| * Copyright (C) 2000 Marcus Metzler <marcus@convergence.de> |
| * & Ralph Metzler <ralph@convergence.de> |
| for convergence integrated media GmbH |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public License |
| * as published by the Free Software Foundation; either version 2.1 |
| * of the License, or (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| * |
| */ |
| #ifndef _DVBNET_H_ |
| #define _DVBNET_H_ |
| #include <asm/types.h> |
| struct dvb_net_if { |
| __u16 pid; |
| __u16 if_num; |
| }; |
| #define NET_ADD_IF _IOWR('o', 52, struct dvb_net_if) |
| #define NET_REMOVE_IF _IO('o', 53) |
| #define NET_GET_IF _IOWR('o', 54, struct dvb_net_if) |
| #endif /*_DVBNET_H_*/ |
| /shark/trunk/drivers/linuxc26/include/linux/dvb/video.h |
|---|
| 0,0 → 1,199 |
| /* |
| * video.h |
| * |
| * Copyright (C) 2000 Marcus Metzler <marcus@convergence.de> |
| * & Ralph Metzler <ralph@convergence.de> |
| for convergence integrated media GmbH |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public License |
| * as published by the Free Software Foundation; either version 2.1 |
| * of the License, or (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| * |
| */ |
| #ifndef _DVBVIDEO_H_ |
| #define _DVBVIDEO_H_ |
| #ifdef __KERNEL__ |
| #include <linux/types.h> |
| #else |
| #include <stdint.h> |
| #include <time.h> |
| #endif |
| typedef enum { |
| VIDEO_FORMAT_4_3, /* Select 4:3 format */ |
| VIDEO_FORMAT_16_9, /* Select 16:9 format. */ |
| VIDEO_FORMAT_221_1 /* 2.21:1 */ |
| } video_format_t; |
| typedef enum { |
| VIDEO_SYSTEM_PAL, |
| VIDEO_SYSTEM_NTSC, |
| VIDEO_SYSTEM_PALN, |
| VIDEO_SYSTEM_PALNc, |
| VIDEO_SYSTEM_PALM, |
| VIDEO_SYSTEM_NTSC60, |
| VIDEO_SYSTEM_PAL60, |
| VIDEO_SYSTEM_PALM60 |
| } video_system_t; |
| typedef enum { |
| VIDEO_PAN_SCAN, /* use pan and scan format */ |
| VIDEO_LETTER_BOX, /* use letterbox format */ |
| VIDEO_CENTER_CUT_OUT /* use center cut out format */ |
| } video_displayformat_t; |
| typedef struct { |
| int w; |
| int h; |
| video_format_t aspect_ratio; |
| } video_size_t; |
| typedef enum { |
| VIDEO_SOURCE_DEMUX, /* Select the demux as the main source */ |
| VIDEO_SOURCE_MEMORY /* If this source is selected, the stream |
| comes from the user through the write |
| system call */ |
| } video_stream_source_t; |
| typedef enum { |
| VIDEO_STOPPED, /* Video is stopped */ |
| VIDEO_PLAYING, /* Video is currently playing */ |
| VIDEO_FREEZED /* Video is freezed */ |
| } video_play_state_t; |
| struct video_event { |
| int32_t type; |
| #define VIDEO_EVENT_SIZE_CHANGED 1 |
| time_t timestamp; |
| union { |
| video_size_t size; |
| } u; |
| }; |
| struct video_status { |
| int video_blank; /* blank video on freeze? */ |
| video_play_state_t play_state; /* current state of playback */ |
| video_stream_source_t stream_source; /* current source (demux/memory) */ |
| video_format_t video_format; /* current aspect ratio of stream*/ |
| video_displayformat_t display_format;/* selected cropping mode */ |
| }; |
| struct video_still_picture { |
| char *iFrame; /* pointer to a single iframe in memory */ |
| int32_t size; |
| }; |
| typedef |
| struct video_highlight { |
| int active; /* 1=show highlight, 0=hide highlight */ |
| uint8_t contrast1; /* 7- 4 Pattern pixel contrast */ |
| /* 3- 0 Background pixel contrast */ |
| uint8_t contrast2; /* 7- 4 Emphasis pixel-2 contrast */ |
| /* 3- 0 Emphasis pixel-1 contrast */ |
| uint8_t color1; /* 7- 4 Pattern pixel color */ |
| /* 3- 0 Background pixel color */ |
| uint8_t color2; /* 7- 4 Emphasis pixel-2 color */ |
| /* 3- 0 Emphasis pixel-1 color */ |
| uint32_t ypos; /* 23-22 auto action mode */ |
| /* 21-12 start y */ |
| /* 9- 0 end y */ |
| uint32_t xpos; /* 23-22 button color number */ |
| /* 21-12 start x */ |
| /* 9- 0 end x */ |
| } video_highlight_t; |
| typedef struct video_spu { |
| int active; |
| int stream_id; |
| } video_spu_t; |
| typedef struct video_spu_palette { /* SPU Palette information */ |
| int length; |
| uint8_t *palette; |
| } video_spu_palette_t; |
| typedef struct video_navi_pack { |
| int length; /* 0 ... 1024 */ |
| uint8_t data[1024]; |
| } video_navi_pack_t; |
| typedef uint16_t video_attributes_t; |
| /* bits: descr. */ |
| /* 15-14 Video compression mode (0=MPEG-1, 1=MPEG-2) */ |
| /* 13-12 TV system (0=525/60, 1=625/50) */ |
| /* 11-10 Aspect ratio (0=4:3, 3=16:9) */ |
| /* 9- 8 permitted display mode on 4:3 monitor (0=both, 1=only pan-sca */ |
| /* 7 line 21-1 data present in GOP (1=yes, 0=no) */ |
| /* 6 line 21-2 data present in GOP (1=yes, 0=no) */ |
| /* 5- 3 source resolution (0=720x480/576, 1=704x480/576, 2=352x480/57 */ |
| /* 2 source letterboxed (1=yes, 0=no) */ |
| /* 0 film/camera mode (0=camera, 1=film (625/50 only)) */ |
| /* bit definitions for capabilities: */ |
| /* can the hardware decode MPEG1 and/or MPEG2? */ |
| #define VIDEO_CAP_MPEG1 1 |
| #define VIDEO_CAP_MPEG2 2 |
| /* can you send a system and/or program stream to video device? |
| (you still have to open the video and the audio device but only |
| send the stream to the video device) */ |
| #define VIDEO_CAP_SYS 4 |
| #define VIDEO_CAP_PROG 8 |
| /* can the driver also handle SPU, NAVI and CSS encoded data? |
| (CSS API is not present yet) */ |
| #define VIDEO_CAP_SPU 16 |
| #define VIDEO_CAP_NAVI 32 |
| #define VIDEO_CAP_CSS 64 |
| #define VIDEO_STOP _IO('o', 21) |
| #define VIDEO_PLAY _IO('o', 22) |
| #define VIDEO_FREEZE _IO('o', 23) |
| #define VIDEO_CONTINUE _IO('o', 24) |
| #define VIDEO_SELECT_SOURCE _IO('o', 25) |
| #define VIDEO_SET_BLANK _IO('o', 26) |
| #define VIDEO_GET_STATUS _IOR('o', 27, struct video_status) |
| #define VIDEO_GET_EVENT _IOR('o', 28, struct video_event) |
| #define VIDEO_SET_DISPLAY_FORMAT _IO('o', 29) |
| #define VIDEO_STILLPICTURE _IOW('o', 30, struct video_still_picture) |
| #define VIDEO_FAST_FORWARD _IO('o', 31) |
| #define VIDEO_SLOWMOTION _IO('o', 32) |
| #define VIDEO_GET_CAPABILITIES _IOR('o', 33, unsigned int) |
| #define VIDEO_CLEAR_BUFFER _IO('o', 34) |
| #define VIDEO_SET_ID _IO('o', 35) |
| #define VIDEO_SET_STREAMTYPE _IO('o', 36) |
| #define VIDEO_SET_FORMAT _IO('o', 37) |
| #define VIDEO_SET_SYSTEM _IO('o', 38) |
| #define VIDEO_SET_HIGHLIGHT _IOW('o', 39, video_highlight_t) |
| #define VIDEO_SET_SPU _IOW('o', 50, video_spu_t) |
| #define VIDEO_SET_SPU_PALETTE _IOW('o', 51, video_spu_palette_t) |
| #define VIDEO_GET_NAVI _IOR('o', 52, video_navi_pack_t) |
| #define VIDEO_SET_ATTRIBUTES _IO('o', 53) |
| #define VIDEO_GET_SIZE _IOR('o', 55, video_size_t) |
| #endif /*_DVBVIDEO_H_*/ |
| /shark/trunk/drivers/linuxc26/include/linux/dvb/dmx.h |
|---|
| 0,0 → 1,180 |
| /* |
| * dmx.h |
| * |
| * Copyright (C) 2000 Marcus Metzler <marcus@convergence.de> |
| * & Ralph Metzler <ralph@convergence.de> |
| for convergence integrated media GmbH |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public License |
| * as published by the Free Software Foundation; either version 2.1 |
| * of the License, or (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| * |
| */ |
| #ifndef _DVBDMX_H_ |
| #define _DVBDMX_H_ |
| #include <asm/types.h> |
| #ifdef __KERNEL__ |
| #include <linux/time.h> |
| #else |
| #include <time.h> |
| #endif |
| #define DMX_FILTER_SIZE 16 |
| typedef enum |
| { |
| DMX_OUT_DECODER, /* Streaming directly to decoder. */ |
| DMX_OUT_TAP, /* Output going to a memory buffer */ |
| /* (to be retrieved via the read command).*/ |
| DMX_OUT_TS_TAP /* Output multiplexed into a new TS */ |
| /* (to be retrieved by reading from the */ |
| /* logical DVR device). */ |
| } dmx_output_t; |
| typedef enum |
| { |
| DMX_IN_FRONTEND, /* Input from a front-end device. */ |
| DMX_IN_DVR /* Input from the logical DVR device. */ |
| } dmx_input_t; |
| typedef enum |
| { |
| DMX_PES_AUDIO0, |
| DMX_PES_VIDEO0, |
| DMX_PES_TELETEXT0, |
| DMX_PES_SUBTITLE0, |
| DMX_PES_PCR0, |
| DMX_PES_AUDIO1, |
| DMX_PES_VIDEO1, |
| DMX_PES_TELETEXT1, |
| DMX_PES_SUBTITLE1, |
| DMX_PES_PCR1, |
| DMX_PES_AUDIO2, |
| DMX_PES_VIDEO2, |
| DMX_PES_TELETEXT2, |
| DMX_PES_SUBTITLE2, |
| DMX_PES_PCR2, |
| DMX_PES_AUDIO3, |
| DMX_PES_VIDEO3, |
| DMX_PES_TELETEXT3, |
| DMX_PES_SUBTITLE3, |
| DMX_PES_PCR3, |
| DMX_PES_OTHER |
| } dmx_pes_type_t; |
| #define DMX_PES_AUDIO DMX_PES_AUDIO0 |
| #define DMX_PES_VIDEO DMX_PES_VIDEO0 |
| #define DMX_PES_TELETEXT DMX_PES_TELETEXT0 |
| #define DMX_PES_SUBTITLE DMX_PES_SUBTITLE0 |
| #define DMX_PES_PCR DMX_PES_PCR0 |
| typedef enum |
| { |
| DMX_SCRAMBLING_EV, |
| DMX_FRONTEND_EV |
| } dmx_event_t; |
| typedef enum |
| { |
| DMX_SCRAMBLING_OFF, |
| DMX_SCRAMBLING_ON |
| } dmx_scrambling_status_t; |
| typedef struct dmx_filter |
| { |
| __u8 filter[DMX_FILTER_SIZE]; |
| __u8 mask[DMX_FILTER_SIZE]; |
| __u8 mode[DMX_FILTER_SIZE]; |
| } dmx_filter_t; |
| struct dmx_sct_filter_params |
| { |
| __u16 pid; |
| dmx_filter_t filter; |
| __u32 timeout; |
| __u32 flags; |
| #define DMX_CHECK_CRC 1 |
| #define DMX_ONESHOT 2 |
| #define DMX_IMMEDIATE_START 4 |
| #define DMX_KERNEL_CLIENT 0x8000 |
| }; |
| struct dmx_pes_filter_params |
| { |
| __u16 pid; |
| dmx_input_t input; |
| dmx_output_t output; |
| dmx_pes_type_t pes_type; |
| __u32 flags; |
| }; |
| struct dmx_event |
| { |
| dmx_event_t event; |
| time_t timeStamp; |
| union |
| { |
| dmx_scrambling_status_t scrambling; |
| } u; |
| }; |
| typedef struct dmx_caps { |
| __u32 caps; |
| int num_decoders; |
| } dmx_caps_t; |
| typedef enum { |
| DMX_SOURCE_FRONT0 = 0, |
| DMX_SOURCE_FRONT1, |
| DMX_SOURCE_FRONT2, |
| DMX_SOURCE_FRONT3, |
| DMX_SOURCE_DVR0 = 16, |
| DMX_SOURCE_DVR1, |
| DMX_SOURCE_DVR2, |
| DMX_SOURCE_DVR3 |
| } dmx_source_t; |
| struct dmx_stc { |
| unsigned int num; /* input : which STC? 0..N */ |
| unsigned int base; /* output: divisor for stc to get 90 kHz clock */ |
| __u64 stc; /* output: stc in 'base'*90 kHz units */ |
| }; |
| #define DMX_START _IO('o',41) |
| #define DMX_STOP _IO('o',42) |
| #define DMX_SET_FILTER _IOW('o',43,struct dmx_sct_filter_params) |
| #define DMX_SET_PES_FILTER _IOW('o',44,struct dmx_pes_filter_params) |
| #define DMX_SET_BUFFER_SIZE _IO('o',45) |
| #define DMX_GET_EVENT _IOR('o',46,struct dmx_event) |
| #define DMX_GET_PES_PIDS _IOR('o', 47, __u16[5]) |
| #define DMX_GET_CAPS _IOR('o',48,dmx_caps_t) |
| #define DMX_SET_SOURCE _IOW('o',49,dmx_source_t) |
| #define DMX_GET_STC _IOWR('o',50,struct dmx_stc) |
| #endif /*_DVBDMX_H_*/ |
| /shark/trunk/drivers/linuxc26/include/linux/byteorder/little_endian.h |
|---|
| 0,0 → 1,68 |
| #ifndef _LINUX_BYTEORDER_LITTLE_ENDIAN_H |
| #define _LINUX_BYTEORDER_LITTLE_ENDIAN_H |
| #ifndef __LITTLE_ENDIAN |
| #define __LITTLE_ENDIAN 1234 |
| #endif |
| #ifndef __LITTLE_ENDIAN_BITFIELD |
| #define __LITTLE_ENDIAN_BITFIELD |
| #endif |
| #include <linux/byteorder/swab.h> |
| #define __constant_htonl(x) ___constant_swab32((x)) |
| #define __constant_ntohl(x) ___constant_swab32((x)) |
| #define __constant_htons(x) ___constant_swab16((x)) |
| #define __constant_ntohs(x) ___constant_swab16((x)) |
| #define __constant_cpu_to_le64(x) ((__u64)(x)) |
| #define __constant_le64_to_cpu(x) ((__u64)(x)) |
| #define __constant_cpu_to_le32(x) ((__u32)(x)) |
| #define __constant_le32_to_cpu(x) ((__u32)(x)) |
| #define __constant_cpu_to_le16(x) ((__u16)(x)) |
| #define __constant_le16_to_cpu(x) ((__u16)(x)) |
| #define __constant_cpu_to_be64(x) ___constant_swab64((x)) |
| #define __constant_be64_to_cpu(x) ___constant_swab64((x)) |
| #define __constant_cpu_to_be32(x) ___constant_swab32((x)) |
| #define __constant_be32_to_cpu(x) ___constant_swab32((x)) |
| #define __constant_cpu_to_be16(x) ___constant_swab16((x)) |
| #define __constant_be16_to_cpu(x) ___constant_swab16((x)) |
| #define __cpu_to_le64(x) ((__u64)(x)) |
| #define __le64_to_cpu(x) ((__u64)(x)) |
| #define __cpu_to_le32(x) ((__u32)(x)) |
| #define __le32_to_cpu(x) ((__u32)(x)) |
| #define __cpu_to_le16(x) ((__u16)(x)) |
| #define __le16_to_cpu(x) ((__u16)(x)) |
| #define __cpu_to_be64(x) __swab64((x)) |
| #define __be64_to_cpu(x) __swab64((x)) |
| #define __cpu_to_be32(x) __swab32((x)) |
| #define __be32_to_cpu(x) __swab32((x)) |
| #define __cpu_to_be16(x) __swab16((x)) |
| #define __be16_to_cpu(x) __swab16((x)) |
| #define __cpu_to_le64p(x) (*(__u64*)(x)) |
| #define __le64_to_cpup(x) (*(__u64*)(x)) |
| #define __cpu_to_le32p(x) (*(__u32*)(x)) |
| #define __le32_to_cpup(x) (*(__u32*)(x)) |
| #define __cpu_to_le16p(x) (*(__u16*)(x)) |
| #define __le16_to_cpup(x) (*(__u16*)(x)) |
| #define __cpu_to_be64p(x) __swab64p((x)) |
| #define __be64_to_cpup(x) __swab64p((x)) |
| #define __cpu_to_be32p(x) __swab32p((x)) |
| #define __be32_to_cpup(x) __swab32p((x)) |
| #define __cpu_to_be16p(x) __swab16p((x)) |
| #define __be16_to_cpup(x) __swab16p((x)) |
| #define __cpu_to_le64s(x) do {} while (0) |
| #define __le64_to_cpus(x) do {} while (0) |
| #define __cpu_to_le32s(x) do {} while (0) |
| #define __le32_to_cpus(x) do {} while (0) |
| #define __cpu_to_le16s(x) do {} while (0) |
| #define __le16_to_cpus(x) do {} while (0) |
| #define __cpu_to_be64s(x) __swab64s((x)) |
| #define __be64_to_cpus(x) __swab64s((x)) |
| #define __cpu_to_be32s(x) __swab32s((x)) |
| #define __be32_to_cpus(x) __swab32s((x)) |
| #define __cpu_to_be16s(x) __swab16s((x)) |
| #define __be16_to_cpus(x) __swab16s((x)) |
| #include <linux/byteorder/generic.h> |
| #endif /* _LINUX_BYTEORDER_LITTLE_ENDIAN_H */ |
| /shark/trunk/drivers/linuxc26/include/linux/byteorder/generic.h |
|---|
| 0,0 → 1,172 |
| #ifndef _LINUX_BYTEORDER_GENERIC_H |
| #define _LINUX_BYTEORDER_GENERIC_H |
| /* |
| * linux/byteorder_generic.h |
| * Generic Byte-reordering support |
| * |
| * Francois-Rene Rideau <fare@tunes.org> 19970707 |
| * gathered all the good ideas from all asm-foo/byteorder.h into one file, |
| * cleaned them up. |
| * I hope it is compliant with non-GCC compilers. |
| * I decided to put __BYTEORDER_HAS_U64__ in byteorder.h, |
| * because I wasn't sure it would be ok to put it in types.h |
| * Upgraded it to 2.1.43 |
| * Francois-Rene Rideau <fare@tunes.org> 19971012 |
| * Upgraded it to 2.1.57 |
| * to please Linus T., replaced huge #ifdef's between little/big endian |
| * by nestedly #include'd files. |
| * Francois-Rene Rideau <fare@tunes.org> 19971205 |
| * Made it to 2.1.71; now a facelift: |
| * Put files under include/linux/byteorder/ |
| * Split swab from generic support. |
| * |
| * TODO: |
| * = Regular kernel maintainers could also replace all these manual |
| * byteswap macros that remain, disseminated among drivers, |
| * after some grep or the sources... |
| * = Linus might want to rename all these macros and files to fit his taste, |
| * to fit his personal naming scheme. |
| * = it seems that a few drivers would also appreciate |
| * nybble swapping support... |
| * = every architecture could add their byteswap macro in asm/byteorder.h |
| * see how some architectures already do (i386, alpha, ppc, etc) |
| * = cpu_to_beXX and beXX_to_cpu might some day need to be well |
| * distinguished throughout the kernel. This is not the case currently, |
| * since little endian, big endian, and pdp endian machines needn't it. |
| * But this might be the case for, say, a port of Linux to 20/21 bit |
| * architectures (and F21 Linux addict around?). |
| */ |
| /* |
| * The following macros are to be defined by <asm/byteorder.h>: |
| * |
| * Conversion of long and short int between network and host format |
| * ntohl(__u32 x) |
| * ntohs(__u16 x) |
| * htonl(__u32 x) |
| * htons(__u16 x) |
| * It seems that some programs (which? where? or perhaps a standard? POSIX?) |
| * might like the above to be functions, not macros (why?). |
| * if that's true, then detect them, and take measures. |
| * Anyway, the measure is: define only ___ntohl as a macro instead, |
| * and in a separate file, have |
| * unsigned long inline ntohl(x){return ___ntohl(x);} |
| * |
| * The same for constant arguments |
| * __constant_ntohl(__u32 x) |
| * __constant_ntohs(__u16 x) |
| * __constant_htonl(__u32 x) |
| * __constant_htons(__u16 x) |
| * |
| * Conversion of XX-bit integers (16- 32- or 64-) |
| * between native CPU format and little/big endian format |
| * 64-bit stuff only defined for proper architectures |
| * cpu_to_[bl]eXX(__uXX x) |
| * [bl]eXX_to_cpu(__uXX x) |
| * |
| * The same, but takes a pointer to the value to convert |
| * cpu_to_[bl]eXXp(__uXX x) |
| * [bl]eXX_to_cpup(__uXX x) |
| * |
| * The same, but change in situ |
| * cpu_to_[bl]eXXs(__uXX x) |
| * [bl]eXX_to_cpus(__uXX x) |
| * |
| * See asm-foo/byteorder.h for examples of how to provide |
| * architecture-optimized versions |
| * |
| */ |
| #if defined(__KERNEL__) |
| /* |
| * inside the kernel, we can use nicknames; |
| * outside of it, we must avoid POSIX namespace pollution... |
| */ |
| #define cpu_to_le64 __cpu_to_le64 |
| #define le64_to_cpu __le64_to_cpu |
| #define cpu_to_le32 __cpu_to_le32 |
| #define le32_to_cpu __le32_to_cpu |
| #define cpu_to_le16 __cpu_to_le16 |
| #define le16_to_cpu __le16_to_cpu |
| #define cpu_to_be64 __cpu_to_be64 |
| #define be64_to_cpu __be64_to_cpu |
| #define cpu_to_be32 __cpu_to_be32 |
| #define be32_to_cpu __be32_to_cpu |
| #define cpu_to_be16 __cpu_to_be16 |
| #define be16_to_cpu __be16_to_cpu |
| #define cpu_to_le64p __cpu_to_le64p |
| #define le64_to_cpup __le64_to_cpup |
| #define cpu_to_le32p __cpu_to_le32p |
| #define le32_to_cpup __le32_to_cpup |
| #define cpu_to_le16p __cpu_to_le16p |
| #define le16_to_cpup __le16_to_cpup |
| #define cpu_to_be64p __cpu_to_be64p |
| #define be64_to_cpup __be64_to_cpup |
| #define cpu_to_be32p __cpu_to_be32p |
| #define be32_to_cpup __be32_to_cpup |
| #define cpu_to_be16p __cpu_to_be16p |
| #define be16_to_cpup __be16_to_cpup |
| #define cpu_to_le64s __cpu_to_le64s |
| #define le64_to_cpus __le64_to_cpus |
| #define cpu_to_le32s __cpu_to_le32s |
| #define le32_to_cpus __le32_to_cpus |
| #define cpu_to_le16s __cpu_to_le16s |
| #define le16_to_cpus __le16_to_cpus |
| #define cpu_to_be64s __cpu_to_be64s |
| #define be64_to_cpus __be64_to_cpus |
| #define cpu_to_be32s __cpu_to_be32s |
| #define be32_to_cpus __be32_to_cpus |
| #define cpu_to_be16s __cpu_to_be16s |
| #define be16_to_cpus __be16_to_cpus |
| #endif |
| #if defined(__KERNEL__) |
| /* |
| * Handle ntohl and suches. These have various compatibility |
| * issues - like we want to give the prototype even though we |
| * also have a macro for them in case some strange program |
| * wants to take the address of the thing or something.. |
| * |
| * Note that these used to return a "long" in libc5, even though |
| * long is often 64-bit these days.. Thus the casts. |
| * |
| * They have to be macros in order to do the constant folding |
| * correctly - if the argument passed into a inline function |
| * it is no longer constant according to gcc.. |
| */ |
| #undef ntohl |
| #undef ntohs |
| #undef htonl |
| #undef htons |
| /* |
| * Do the prototypes. Somebody might want to take the |
| * address or some such sick thing.. |
| */ |
| extern __u32 ntohl(__u32); |
| extern __u32 htonl(__u32); |
| extern unsigned short int ntohs(unsigned short int); |
| extern unsigned short int htons(unsigned short int); |
| #if defined(__GNUC__) && (__GNUC__ >= 2) && defined(__OPTIMIZE__) |
| #define ___htonl(x) __cpu_to_be32(x) |
| #define ___htons(x) __cpu_to_be16(x) |
| #define ___ntohl(x) __be32_to_cpu(x) |
| #define ___ntohs(x) __be16_to_cpu(x) |
| #define htonl(x) ___htonl(x) |
| #define ntohl(x) ___ntohl(x) |
| #define htons(x) ___htons(x) |
| #define ntohs(x) ___ntohs(x) |
| #endif /* OPTIMIZE */ |
| #endif /* KERNEL */ |
| #endif /* _LINUX_BYTEORDER_GENERIC_H */ |
| /shark/trunk/drivers/linuxc26/include/linux/byteorder/swab.h |
|---|
| 0,0 → 1,190 |
| #ifndef _LINUX_BYTEORDER_SWAB_H |
| #define _LINUX_BYTEORDER_SWAB_H |
| /* |
| * linux/byteorder/swab.h |
| * Byte-swapping, independently from CPU endianness |
| * swabXX[ps]?(foo) |
| * |
| * Francois-Rene Rideau <fare@tunes.org> 19971205 |
| * separated swab functions from cpu_to_XX, |
| * to clean up support for bizarre-endian architectures. |
| * |
| * See asm-i386/byteorder.h and suches for examples of how to provide |
| * architecture-dependent optimized versions |
| * |
| */ |
| /* casts are necessary for constants, because we never know how for sure |
| * how U/UL/ULL map to __u16, __u32, __u64. At least not in a portable way. |
| */ |
| #define ___swab16(x) \ |
| ({ \ |
| __u16 __x = (x); \ |
| ((__u16)( \ |
| (((__u16)(__x) & (__u16)0x00ffU) << 8) | \ |
| (((__u16)(__x) & (__u16)0xff00U) >> 8) )); \ |
| }) |
| #define ___swab32(x) \ |
| ({ \ |
| __u32 __x = (x); \ |
| ((__u32)( \ |
| (((__u32)(__x) & (__u32)0x000000ffUL) << 24) | \ |
| (((__u32)(__x) & (__u32)0x0000ff00UL) << 8) | \ |
| (((__u32)(__x) & (__u32)0x00ff0000UL) >> 8) | \ |
| (((__u32)(__x) & (__u32)0xff000000UL) >> 24) )); \ |
| }) |
| #define ___swab64(x) \ |
| ({ \ |
| __u64 __x = (x); \ |
| ((__u64)( \ |
| (__u64)(((__u64)(__x) & (__u64)0x00000000000000ffULL) << 56) | \ |
| (__u64)(((__u64)(__x) & (__u64)0x000000000000ff00ULL) << 40) | \ |
| (__u64)(((__u64)(__x) & (__u64)0x0000000000ff0000ULL) << 24) | \ |
| (__u64)(((__u64)(__x) & (__u64)0x00000000ff000000ULL) << 8) | \ |
| (__u64)(((__u64)(__x) & (__u64)0x000000ff00000000ULL) >> 8) | \ |
| (__u64)(((__u64)(__x) & (__u64)0x0000ff0000000000ULL) >> 24) | \ |
| (__u64)(((__u64)(__x) & (__u64)0x00ff000000000000ULL) >> 40) | \ |
| (__u64)(((__u64)(__x) & (__u64)0xff00000000000000ULL) >> 56) )); \ |
| }) |
| #define ___constant_swab16(x) \ |
| ((__u16)( \ |
| (((__u16)(x) & (__u16)0x00ffU) << 8) | \ |
| (((__u16)(x) & (__u16)0xff00U) >> 8) )) |
| #define ___constant_swab32(x) \ |
| ((__u32)( \ |
| (((__u32)(x) & (__u32)0x000000ffUL) << 24) | \ |
| (((__u32)(x) & (__u32)0x0000ff00UL) << 8) | \ |
| (((__u32)(x) & (__u32)0x00ff0000UL) >> 8) | \ |
| (((__u32)(x) & (__u32)0xff000000UL) >> 24) )) |
| #define ___constant_swab64(x) \ |
| ((__u64)( \ |
| (__u64)(((__u64)(x) & (__u64)0x00000000000000ffULL) << 56) | \ |
| (__u64)(((__u64)(x) & (__u64)0x000000000000ff00ULL) << 40) | \ |
| (__u64)(((__u64)(x) & (__u64)0x0000000000ff0000ULL) << 24) | \ |
| (__u64)(((__u64)(x) & (__u64)0x00000000ff000000ULL) << 8) | \ |
| (__u64)(((__u64)(x) & (__u64)0x000000ff00000000ULL) >> 8) | \ |
| (__u64)(((__u64)(x) & (__u64)0x0000ff0000000000ULL) >> 24) | \ |
| (__u64)(((__u64)(x) & (__u64)0x00ff000000000000ULL) >> 40) | \ |
| (__u64)(((__u64)(x) & (__u64)0xff00000000000000ULL) >> 56) )) |
| /* |
| * provide defaults when no architecture-specific optimization is detected |
| */ |
| #ifndef __arch__swab16 |
| # define __arch__swab16(x) ({ __u16 __tmp = (x) ; ___swab16(__tmp); }) |
| #endif |
| #ifndef __arch__swab32 |
| # define __arch__swab32(x) ({ __u32 __tmp = (x) ; ___swab32(__tmp); }) |
| #endif |
| #ifndef __arch__swab64 |
| # define __arch__swab64(x) ({ __u64 __tmp = (x) ; ___swab64(__tmp); }) |
| #endif |
| #ifndef __arch__swab16p |
| # define __arch__swab16p(x) __arch__swab16(*(x)) |
| #endif |
| #ifndef __arch__swab32p |
| # define __arch__swab32p(x) __arch__swab32(*(x)) |
| #endif |
| #ifndef __arch__swab64p |
| # define __arch__swab64p(x) __arch__swab64(*(x)) |
| #endif |
| #ifndef __arch__swab16s |
| # define __arch__swab16s(x) do { *(x) = __arch__swab16p((x)); } while (0) |
| #endif |
| #ifndef __arch__swab32s |
| # define __arch__swab32s(x) do { *(x) = __arch__swab32p((x)); } while (0) |
| #endif |
| #ifndef __arch__swab64s |
| # define __arch__swab64s(x) do { *(x) = __arch__swab64p((x)); } while (0) |
| #endif |
| /* |
| * Allow constant folding |
| */ |
| #if defined(__GNUC__) && (__GNUC__ >= 2) && defined(__OPTIMIZE__) |
| # define __swab16(x) \ |
| (__builtin_constant_p((__u16)(x)) ? \ |
| ___swab16((x)) : \ |
| __fswab16((x))) |
| # define __swab32(x) \ |
| (__builtin_constant_p((__u32)(x)) ? \ |
| ___swab32((x)) : \ |
| __fswab32((x))) |
| # define __swab64(x) \ |
| (__builtin_constant_p((__u64)(x)) ? \ |
| ___swab64((x)) : \ |
| __fswab64((x))) |
| #else |
| # define __swab16(x) __fswab16(x) |
| # define __swab32(x) __fswab32(x) |
| # define __swab64(x) __fswab64(x) |
| #endif /* OPTIMIZE */ |
| static __inline__ __const__ __u16 __fswab16(__u16 x) |
| { |
| return __arch__swab16(x); |
| } |
| static __inline__ __u16 __swab16p(__u16 *x) |
| { |
| return __arch__swab16p(x); |
| } |
| static __inline__ void __swab16s(__u16 *addr) |
| { |
| __arch__swab16s(addr); |
| } |
| static __inline__ __const__ __u32 __fswab32(__u32 x) |
| { |
| return __arch__swab32(x); |
| } |
| static __inline__ __u32 __swab32p(__u32 *x) |
| { |
| return __arch__swab32p(x); |
| } |
| static __inline__ void __swab32s(__u32 *addr) |
| { |
| __arch__swab32s(addr); |
| } |
| #ifdef __BYTEORDER_HAS_U64__ |
| static __inline__ __const__ __u64 __fswab64(__u64 x) |
| { |
| # ifdef __SWAB_64_THRU_32__ |
| __u32 h = x >> 32; |
| __u32 l = x & ((1ULL<<32)-1); |
| return (((__u64)__swab32(l)) << 32) | ((__u64)(__swab32(h))); |
| # else |
| return __arch__swab64(x); |
| # endif |
| } |
| static __inline__ __u64 __swab64p(__u64 *x) |
| { |
| return __arch__swab64p(x); |
| } |
| static __inline__ void __swab64s(__u64 *addr) |
| { |
| __arch__swab64s(addr); |
| } |
| #endif /* __BYTEORDER_HAS_U64__ */ |
| #if defined(__KERNEL__) |
| #define swab16 __swab16 |
| #define swab32 __swab32 |
| #define swab64 __swab64 |
| #define swab16p __swab16p |
| #define swab32p __swab32p |
| #define swab64p __swab64p |
| #define swab16s __swab16s |
| #define swab32s __swab32s |
| #define swab64s __swab64s |
| #endif |
| #endif /* _LINUX_BYTEORDER_SWAB_H */ |
| /shark/trunk/drivers/linuxc26/include/linux/byteorder/swabb.h |
|---|
| 0,0 → 1,137 |
| #ifndef _LINUX_BYTEORDER_SWABB_H |
| #define _LINUX_BYTEORDER_SWABB_H |
| /* |
| * linux/byteorder/swabb.h |
| * SWAp Bytes Bizarrely |
| * swaHHXX[ps]?(foo) |
| * |
| * Support for obNUXIous pdp-endian and other bizarre architectures. |
| * Will Linux ever run on such ancient beasts? if not, this file |
| * will be but a programming pearl. Still, it's a reminder that we |
| * shouldn't be making too many assumptions when trying to be portable. |
| * |
| */ |
| /* |
| * Meaning of the names I chose (vaxlinux people feel free to correct them): |
| * swahw32 swap 16-bit half-words in a 32-bit word |
| * swahb32 swap 8-bit halves of each 16-bit half-word in a 32-bit word |
| * |
| * No 64-bit support yet. I don't know NUXI conventions for long longs. |
| * I guarantee it will be a mess when it's there, though :-> |
| * It will be even worse if there are conflicting 64-bit conventions. |
| * Hopefully, no one ever used 64-bit objects on NUXI machines. |
| * |
| */ |
| #define ___swahw32(x) \ |
| ({ \ |
| __u32 __x = (x); \ |
| ((__u32)( \ |
| (((__u32)(__x) & (__u32)0x0000ffffUL) << 16) | \ |
| (((__u32)(__x) & (__u32)0xffff0000UL) >> 16) )); \ |
| }) |
| #define ___swahb32(x) \ |
| ({ \ |
| __u32 __x = (x); \ |
| ((__u32)( \ |
| (((__u32)(__x) & (__u32)0x00ff00ffUL) << 8) | \ |
| (((__u32)(__x) & (__u32)0xff00ff00UL) >> 8) )); \ |
| }) |
| #define ___constant_swahw32(x) \ |
| ((__u32)( \ |
| (((__u32)(x) & (__u32)0x0000ffffUL) << 16) | \ |
| (((__u32)(x) & (__u32)0xffff0000UL) >> 16) )) |
| #define ___constant_swahb32(x) \ |
| ((__u32)( \ |
| (((__u32)(x) & (__u32)0x00ff00ffUL) << 8) | \ |
| (((__u32)(x) & (__u32)0xff00ff00UL) >> 8) )) |
| /* |
| * provide defaults when no architecture-specific optimization is detected |
| */ |
| #ifndef __arch__swahw32 |
| # define __arch__swahw32(x) ___swahw32(x) |
| #endif |
| #ifndef __arch__swahb32 |
| # define __arch__swahb32(x) ___swahb32(x) |
| #endif |
| #ifndef __arch__swahw32p |
| # define __arch__swahw32p(x) __swahw32(*(x)) |
| #endif |
| #ifndef __arch__swahb32p |
| # define __arch__swahb32p(x) __swahb32(*(x)) |
| #endif |
| #ifndef __arch__swahw32s |
| # define __arch__swahw32s(x) do { *(x) = __swahw32p((x)); } while (0) |
| #endif |
| #ifndef __arch__swahb32s |
| # define __arch__swahb32s(x) do { *(x) = __swahb32p((x)); } while (0) |
| #endif |
| /* |
| * Allow constant folding |
| */ |
| #if defined(__GNUC__) && (__GNUC__ >= 2) && defined(__OPTIMIZE__) |
| # define __swahw32(x) \ |
| (__builtin_constant_p((__u32)(x)) ? \ |
| ___swahw32((x)) : \ |
| __fswahw32((x))) |
| # define __swahb32(x) \ |
| (__builtin_constant_p((__u32)(x)) ? \ |
| ___swahb32((x)) : \ |
| __fswahb32((x))) |
| #else |
| # define __swahw32(x) __fswahw32(x) |
| # define __swahb32(x) __fswahb32(x) |
| #endif /* OPTIMIZE */ |
| static __inline__ __const__ __u32 __fswahw32(__u32 x) |
| { |
| return __arch__swahw32(x); |
| } |
| static __inline__ __u32 __swahw32p(__u32 *x) |
| { |
| return __arch__swahw32p(x); |
| } |
| static __inline__ void __swahw32s(__u32 *addr) |
| { |
| __arch__swahw32s(addr); |
| } |
| static __inline__ __const__ __u32 __fswahb32(__u32 x) |
| { |
| return __arch__swahb32(x); |
| } |
| static __inline__ __u32 __swahb32p(__u32 *x) |
| { |
| return __arch__swahb32p(x); |
| } |
| static __inline__ void __swahb32s(__u32 *addr) |
| { |
| __arch__swahb32s(addr); |
| } |
| #ifdef __BYTEORDER_HAS_U64__ |
| /* |
| * Not supported yet |
| */ |
| #endif /* __BYTEORDER_HAS_U64__ */ |
| #if defined(__KERNEL__) |
| #define swahw32 __swahw32 |
| #define swahb32 __swahb32 |
| #define swahw32p __swahw32p |
| #define swahb32p __swahb32p |
| #define swahw32s __swahw32s |
| #define swahb32s __swahb32s |
| #endif |
| #endif /* _LINUX_BYTEORDER_SWABB_H */ |
| /shark/trunk/drivers/linuxc26/include/linux/byteorder/big_endian.h |
|---|
| 0,0 → 1,68 |
| #ifndef _LINUX_BYTEORDER_BIG_ENDIAN_H |
| #define _LINUX_BYTEORDER_BIG_ENDIAN_H |
| #ifndef __BIG_ENDIAN |
| #define __BIG_ENDIAN 4321 |
| #endif |
| #ifndef __BIG_ENDIAN_BITFIELD |
| #define __BIG_ENDIAN_BITFIELD |
| #endif |
| #include <linux/byteorder/swab.h> |
| #define __constant_htonl(x) ((__u32)(x)) |
| #define __constant_ntohl(x) ((__u32)(x)) |
| #define __constant_htons(x) ((__u16)(x)) |
| #define __constant_ntohs(x) ((__u16)(x)) |
| #define __constant_cpu_to_le64(x) ___constant_swab64((x)) |
| #define __constant_le64_to_cpu(x) ___constant_swab64((x)) |
| #define __constant_cpu_to_le32(x) ___constant_swab32((x)) |
| #define __constant_le32_to_cpu(x) ___constant_swab32((x)) |
| #define __constant_cpu_to_le16(x) ___constant_swab16((x)) |
| #define __constant_le16_to_cpu(x) ___constant_swab16((x)) |
| #define __constant_cpu_to_be64(x) ((__u64)(x)) |
| #define __constant_be64_to_cpu(x) ((__u64)(x)) |
| #define __constant_cpu_to_be32(x) ((__u32)(x)) |
| #define __constant_be32_to_cpu(x) ((__u32)(x)) |
| #define __constant_cpu_to_be16(x) ((__u16)(x)) |
| #define __constant_be16_to_cpu(x) ((__u16)(x)) |
| #define __cpu_to_le64(x) __swab64((x)) |
| #define __le64_to_cpu(x) __swab64((x)) |
| #define __cpu_to_le32(x) __swab32((x)) |
| #define __le32_to_cpu(x) __swab32((x)) |
| #define __cpu_to_le16(x) __swab16((x)) |
| #define __le16_to_cpu(x) __swab16((x)) |
| #define __cpu_to_be64(x) ((__u64)(x)) |
| #define __be64_to_cpu(x) ((__u64)(x)) |
| #define __cpu_to_be32(x) ((__u32)(x)) |
| #define __be32_to_cpu(x) ((__u32)(x)) |
| #define __cpu_to_be16(x) ((__u16)(x)) |
| #define __be16_to_cpu(x) ((__u16)(x)) |
| #define __cpu_to_le64p(x) __swab64p((x)) |
| #define __le64_to_cpup(x) __swab64p((x)) |
| #define __cpu_to_le32p(x) __swab32p((x)) |
| #define __le32_to_cpup(x) __swab32p((x)) |
| #define __cpu_to_le16p(x) __swab16p((x)) |
| #define __le16_to_cpup(x) __swab16p((x)) |
| #define __cpu_to_be64p(x) (*(__u64*)(x)) |
| #define __be64_to_cpup(x) (*(__u64*)(x)) |
| #define __cpu_to_be32p(x) (*(__u32*)(x)) |
| #define __be32_to_cpup(x) (*(__u32*)(x)) |
| #define __cpu_to_be16p(x) (*(__u16*)(x)) |
| #define __be16_to_cpup(x) (*(__u16*)(x)) |
| #define __cpu_to_le64s(x) __swab64s((x)) |
| #define __le64_to_cpus(x) __swab64s((x)) |
| #define __cpu_to_le32s(x) __swab32s((x)) |
| #define __le32_to_cpus(x) __swab32s((x)) |
| #define __cpu_to_le16s(x) __swab16s((x)) |
| #define __le16_to_cpus(x) __swab16s((x)) |
| #define __cpu_to_be64s(x) do {} while (0) |
| #define __be64_to_cpus(x) do {} while (0) |
| #define __cpu_to_be32s(x) do {} while (0) |
| #define __be32_to_cpus(x) do {} while (0) |
| #define __cpu_to_be16s(x) do {} while (0) |
| #define __be16_to_cpus(x) do {} while (0) |
| #include <linux/byteorder/generic.h> |
| #endif /* _LINUX_BYTEORDER_BIG_ENDIAN_H */ |
| /shark/trunk/drivers/linuxc26/include/linux/byteorder/pdp_endian.h |
|---|
| 0,0 → 1,88 |
| #ifndef _LINUX_BYTEORDER_PDP_ENDIAN_H |
| #define _LINUX_BYTEORDER_PDP_ENDIAN_H |
| /* |
| * Could have been named NUXI-endian, but we use the same name as in glibc. |
| * hopefully only the PDP and its evolutions (old VAXen in compatibility mode) |
| * should ever use this braindead byteorder. |
| * This file *should* work, but has not been tested. |
| * |
| * little-endian is 1234; big-endian is 4321; nuxi/pdp-endian is 3412 |
| * |
| * I thought vaxen were NUXI-endian, but was told they were correct-endian |
| * (little-endian), though indeed there existed NUXI-endian machines |
| * (DEC PDP-11 and old VAXen in compatibility mode). |
| * This makes this file a bit useless, but as a proof-of-concept. |
| * |
| * But what does a __u64 look like: is it 34127856 or 78563412 ??? |
| * I don't dare imagine! Hence, no 64-bit byteorder support yet. |
| * Hopefully, there 64-bit pdp-endian support shouldn't ever be required. |
| * |
| */ |
| #ifndef __PDP_ENDIAN |
| #define __PDP_ENDIAN 3412 |
| #endif |
| #ifndef __PDP_ENDIAN_BITFIELD |
| #define __PDP_ENDIAN_BITFIELD |
| #endif |
| #include <linux/byteorder/swab.h> |
| #include <linux/byteorder/swabb.h> |
| #define __constant_htonl(x) ___constant_swahb32((x)) |
| #define __constant_ntohl(x) ___constant_swahb32((x)) |
| #define __constant_htons(x) ___constant_swab16((x)) |
| #define __constant_ntohs(x) ___constant_swab16((x)) |
| #define __constant_cpu_to_le64(x) I DON'T KNOW |
| #define __constant_le64_to_cpu(x) I DON'T KNOW |
| #define __constant_cpu_to_le32(x) ___constant_swahw32((x)) |
| #define __constant_le32_to_cpu(x) ___constant_swahw32((x)) |
| #define __constant_cpu_to_le16(x) ((__u16)(x) |
| #define __constant_le16_to_cpu(x) ((__u16)(x) |
| #define __constant_cpu_to_be64(x) I DON'T KNOW |
| #define __constant_be64_to_cpu(x) I DON'T KNOW |
| #define __constant_cpu_to_be32(x) ___constant_swahb32((x)) |
| #define __constant_be32_to_cpu(x) ___constant_swahb32((x)) |
| #define __constant_cpu_to_be16(x) ___constant_swab16((x)) |
| #define __constant_be16_to_cpu(x) ___constant_swab16((x)) |
| #define __cpu_to_le64(x) I DON'T KNOW |
| #define __le64_to_cpu(x) I DON'T KNOW |
| #define __cpu_to_le32(x) ___swahw32((x)) |
| #define __le32_to_cpu(x) ___swahw32((x)) |
| #define __cpu_to_le16(x) ((__u16)(x) |
| #define __le16_to_cpu(x) ((__u16)(x) |
| #define __cpu_to_be64(x) I DON'T KNOW |
| #define __be64_to_cpu(x) I DON'T KNOW |
| #define __cpu_to_be32(x) __swahb32((x)) |
| #define __be32_to_cpu(x) __swahb32((x)) |
| #define __cpu_to_be16(x) __swab16((x)) |
| #define __be16_to_cpu(x) __swab16((x)) |
| #define __cpu_to_le64p(x) I DON'T KNOW |
| #define __le64_to_cpup(x) I DON'T KNOW |
| #define __cpu_to_le32p(x) ___swahw32p((x)) |
| #define __le32_to_cpup(x) ___swahw32p((x)) |
| #define __cpu_to_le16p(x) (*(__u16*)(x)) |
| #define __le16_to_cpup(x) (*(__u16*)(x)) |
| #define __cpu_to_be64p(x) I DON'T KNOW |
| #define __be64_to_cpup(x) I DON'T KNOW |
| #define __cpu_to_be32p(x) __swahb32p((x)) |
| #define __be32_to_cpup(x) __swahb32p((x)) |
| #define __cpu_to_be16p(x) __swab16p((x)) |
| #define __be16_to_cpup(x) __swab16p((x)) |
| #define __cpu_to_le64s(x) I DON'T KNOW |
| #define __le64_to_cpus(x) I DON'T KNOW |
| #define __cpu_to_le32s(x) ___swahw32s((x)) |
| #define __le32_to_cpus(x) ___swahw32s((x)) |
| #define __cpu_to_le16s(x) do {} while (0) |
| #define __le16_to_cpus(x) do {} while (0) |
| #define __cpu_to_be64s(x) I DON'T KNOW |
| #define __be64_to_cpus(x) I DON'T KNOW |
| #define __cpu_to_be32s(x) __swahb32s((x)) |
| #define __be32_to_cpus(x) __swahb32s((x)) |
| #define __cpu_to_be16s(x) __swab16s((x)) |
| #define __be16_to_cpus(x) __swab16s((x)) |
| #include <linux/byteorder/generic.h> |
| #endif /* _LINUX_BYTEORDER_PDP_ENDIAN_H */ |
| /shark/trunk/drivers/linuxc26/include/linux/isdn/capiutil.h |
|---|
| 0,0 → 1,505 |
| /* $Id: capiutil.h,v 1.1 2004-01-28 15:32:46 giacomo Exp $ |
| * |
| * CAPI 2.0 defines & types |
| * |
| * From CAPI 2.0 Development Kit AVM 1995 (msg.c) |
| * Rewritten for Linux 1996 by Carsten Paeth <calle@calle.de> |
| * |
| * This software may be used and distributed according to the terms |
| * of the GNU General Public License, incorporated herein by reference. |
| * |
| */ |
| #ifndef __CAPIUTIL_H__ |
| #define __CAPIUTIL_H__ |
| #include <asm/types.h> |
| #define CAPIMSG_BASELEN 8 |
| #define CAPIMSG_U8(m, off) (m[off]) |
| #define CAPIMSG_U16(m, off) (m[off]|(m[(off)+1]<<8)) |
| #define CAPIMSG_U32(m, off) (m[off]|(m[(off)+1]<<8)|(m[(off)+2]<<16)|(m[(off)+3]<<24)) |
| #define CAPIMSG_LEN(m) CAPIMSG_U16(m,0) |
| #define CAPIMSG_APPID(m) CAPIMSG_U16(m,2) |
| #define CAPIMSG_COMMAND(m) CAPIMSG_U8(m,4) |
| #define CAPIMSG_SUBCOMMAND(m) CAPIMSG_U8(m,5) |
| #define CAPIMSG_CMD(m) (((m[4])<<8)|(m[5])) |
| #define CAPIMSG_MSGID(m) CAPIMSG_U16(m,6) |
| #define CAPIMSG_CONTROLLER(m) (m[8] & 0x7f) |
| #define CAPIMSG_CONTROL(m) CAPIMSG_U32(m, 8) |
| #define CAPIMSG_NCCI(m) CAPIMSG_CONTROL(m) |
| #define CAPIMSG_DATALEN(m) CAPIMSG_U16(m,16) /* DATA_B3_REQ */ |
| static inline void capimsg_setu8(void *m, int off, __u8 val) |
| { |
| ((__u8 *)m)[off] = val; |
| } |
| static inline void capimsg_setu16(void *m, int off, __u16 val) |
| { |
| ((__u8 *)m)[off] = val & 0xff; |
| ((__u8 *)m)[off+1] = (val >> 8) & 0xff; |
| } |
| static inline void capimsg_setu32(void *m, int off, __u32 val) |
| { |
| ((__u8 *)m)[off] = val & 0xff; |
| ((__u8 *)m)[off+1] = (val >> 8) & 0xff; |
| ((__u8 *)m)[off+2] = (val >> 16) & 0xff; |
| ((__u8 *)m)[off+3] = (val >> 24) & 0xff; |
| } |
| #define CAPIMSG_SETLEN(m, len) capimsg_setu16(m, 0, len) |
| #define CAPIMSG_SETAPPID(m, applid) capimsg_setu16(m, 2, applid) |
| #define CAPIMSG_SETCOMMAND(m,cmd) capimsg_setu8(m, 4, cmd) |
| #define CAPIMSG_SETSUBCOMMAND(m, cmd) capimsg_setu8(m, 5, cmd) |
| #define CAPIMSG_SETMSGID(m, msgid) capimsg_setu16(m, 6, msgid) |
| #define CAPIMSG_SETCONTROL(m, contr) capimsg_setu32(m, 8, contr) |
| #define CAPIMSG_SETDATALEN(m, len) capimsg_setu16(m, 16, len) |
| /*----- basic-type definitions -----*/ |
| typedef __u8 *_cstruct; |
| typedef enum { |
| CAPI_COMPOSE, |
| CAPI_DEFAULT |
| } _cmstruct; |
| /* |
| The _cmsg structure contains all possible CAPI 2.0 parameter. |
| All parameters are stored here first. The function CAPI_CMSG_2_MESSAGE |
| assembles the parameter and builds CAPI2.0 conform messages. |
| CAPI_MESSAGE_2_CMSG disassembles CAPI 2.0 messages and stores the |
| parameter in the _cmsg structure |
| */ |
| typedef struct { |
| /* Header */ |
| __u16 ApplId; |
| __u8 Command; |
| __u8 Subcommand; |
| __u16 Messagenumber; |
| /* Parameter */ |
| union { |
| __u32 adrController; |
| __u32 adrPLCI; |
| __u32 adrNCCI; |
| } adr; |
| _cmstruct AdditionalInfo; |
| _cstruct B1configuration; |
| __u16 B1protocol; |
| _cstruct B2configuration; |
| __u16 B2protocol; |
| _cstruct B3configuration; |
| __u16 B3protocol; |
| _cstruct BC; |
| _cstruct BChannelinformation; |
| _cmstruct BProtocol; |
| _cstruct CalledPartyNumber; |
| _cstruct CalledPartySubaddress; |
| _cstruct CallingPartyNumber; |
| _cstruct CallingPartySubaddress; |
| __u32 CIPmask; |
| __u32 CIPmask2; |
| __u16 CIPValue; |
| __u32 Class; |
| _cstruct ConnectedNumber; |
| _cstruct ConnectedSubaddress; |
| __u32 Data; |
| __u16 DataHandle; |
| __u16 DataLength; |
| _cstruct FacilityConfirmationParameter; |
| _cstruct Facilitydataarray; |
| _cstruct FacilityIndicationParameter; |
| _cstruct FacilityRequestParameter; |
| __u16 FacilitySelector; |
| __u16 Flags; |
| __u32 Function; |
| _cstruct HLC; |
| __u16 Info; |
| _cstruct InfoElement; |
| __u32 InfoMask; |
| __u16 InfoNumber; |
| _cstruct Keypadfacility; |
| _cstruct LLC; |
| _cstruct ManuData; |
| __u32 ManuID; |
| _cstruct NCPI; |
| __u16 Reason; |
| __u16 Reason_B3; |
| __u16 Reject; |
| _cstruct Useruserdata; |
| /* intern */ |
| unsigned l, p; |
| unsigned char *par; |
| __u8 *m; |
| /* buffer to construct message */ |
| __u8 buf[180]; |
| } _cmsg; |
| /* |
| * capi_cmsg2message() assembles the parameter from _cmsg to a CAPI 2.0 |
| * conform message |
| */ |
| unsigned capi_cmsg2message(_cmsg * cmsg, __u8 * msg); |
| /* |
| * capi_message2cmsg disassembles a CAPI message an writes the parameter |
| * into _cmsg for easy access |
| */ |
| unsigned capi_message2cmsg(_cmsg * cmsg, __u8 * msg); |
| /* |
| * capi_cmsg_header() fills the _cmsg structure with default values, so only |
| * parameter with non default values must be changed before sending the |
| * message. |
| */ |
| unsigned capi_cmsg_header(_cmsg * cmsg, __u16 _ApplId, |
| __u8 _Command, __u8 _Subcommand, |
| __u16 _Messagenumber, __u32 _Controller); |
| /* |
| * capi_info2str generated a readable string for Capi2.0 reasons. |
| */ |
| char *capi_info2str(__u16 reason); |
| /*-----------------------------------------------------------------------*/ |
| /* |
| * Debugging / Tracing functions |
| */ |
| char *capi_cmd2str(__u8 cmd, __u8 subcmd); |
| char *capi_cmsg2str(_cmsg * cmsg); |
| char *capi_message2str(__u8 * msg); |
| /*-----------------------------------------------------------------------*/ |
| static inline void capi_cmsg_answer(_cmsg * cmsg) |
| { |
| cmsg->Subcommand |= 0x01; |
| } |
| /*-----------------------------------------------------------------------*/ |
| static inline void capi_fill_CONNECT_B3_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr, |
| _cstruct NCPI) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x82, 0x80, Messagenumber, adr); |
| cmsg->NCPI = NCPI; |
| } |
| static inline void capi_fill_FACILITY_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr, |
| __u16 FacilitySelector, |
| _cstruct FacilityRequestParameter) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x80, 0x80, Messagenumber, adr); |
| cmsg->FacilitySelector = FacilitySelector; |
| cmsg->FacilityRequestParameter = FacilityRequestParameter; |
| } |
| static inline void capi_fill_INFO_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr, |
| _cstruct CalledPartyNumber, |
| _cstruct BChannelinformation, |
| _cstruct Keypadfacility, |
| _cstruct Useruserdata, |
| _cstruct Facilitydataarray) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x08, 0x80, Messagenumber, adr); |
| cmsg->CalledPartyNumber = CalledPartyNumber; |
| cmsg->BChannelinformation = BChannelinformation; |
| cmsg->Keypadfacility = Keypadfacility; |
| cmsg->Useruserdata = Useruserdata; |
| cmsg->Facilitydataarray = Facilitydataarray; |
| } |
| static inline void capi_fill_LISTEN_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr, |
| __u32 InfoMask, |
| __u32 CIPmask, |
| __u32 CIPmask2, |
| _cstruct CallingPartyNumber, |
| _cstruct CallingPartySubaddress) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x05, 0x80, Messagenumber, adr); |
| cmsg->InfoMask = InfoMask; |
| cmsg->CIPmask = CIPmask; |
| cmsg->CIPmask2 = CIPmask2; |
| cmsg->CallingPartyNumber = CallingPartyNumber; |
| cmsg->CallingPartySubaddress = CallingPartySubaddress; |
| } |
| static inline void capi_fill_ALERT_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr, |
| _cstruct BChannelinformation, |
| _cstruct Keypadfacility, |
| _cstruct Useruserdata, |
| _cstruct Facilitydataarray) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x01, 0x80, Messagenumber, adr); |
| cmsg->BChannelinformation = BChannelinformation; |
| cmsg->Keypadfacility = Keypadfacility; |
| cmsg->Useruserdata = Useruserdata; |
| cmsg->Facilitydataarray = Facilitydataarray; |
| } |
| static inline void capi_fill_CONNECT_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr, |
| __u16 CIPValue, |
| _cstruct CalledPartyNumber, |
| _cstruct CallingPartyNumber, |
| _cstruct CalledPartySubaddress, |
| _cstruct CallingPartySubaddress, |
| __u16 B1protocol, |
| __u16 B2protocol, |
| __u16 B3protocol, |
| _cstruct B1configuration, |
| _cstruct B2configuration, |
| _cstruct B3configuration, |
| _cstruct BC, |
| _cstruct LLC, |
| _cstruct HLC, |
| _cstruct BChannelinformation, |
| _cstruct Keypadfacility, |
| _cstruct Useruserdata, |
| _cstruct Facilitydataarray) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x02, 0x80, Messagenumber, adr); |
| cmsg->CIPValue = CIPValue; |
| cmsg->CalledPartyNumber = CalledPartyNumber; |
| cmsg->CallingPartyNumber = CallingPartyNumber; |
| cmsg->CalledPartySubaddress = CalledPartySubaddress; |
| cmsg->CallingPartySubaddress = CallingPartySubaddress; |
| cmsg->B1protocol = B1protocol; |
| cmsg->B2protocol = B2protocol; |
| cmsg->B3protocol = B3protocol; |
| cmsg->B1configuration = B1configuration; |
| cmsg->B2configuration = B2configuration; |
| cmsg->B3configuration = B3configuration; |
| cmsg->BC = BC; |
| cmsg->LLC = LLC; |
| cmsg->HLC = HLC; |
| cmsg->BChannelinformation = BChannelinformation; |
| cmsg->Keypadfacility = Keypadfacility; |
| cmsg->Useruserdata = Useruserdata; |
| cmsg->Facilitydataarray = Facilitydataarray; |
| } |
| static inline void capi_fill_DATA_B3_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr, |
| __u32 Data, |
| __u16 DataLength, |
| __u16 DataHandle, |
| __u16 Flags) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x86, 0x80, Messagenumber, adr); |
| cmsg->Data = Data; |
| cmsg->DataLength = DataLength; |
| cmsg->DataHandle = DataHandle; |
| cmsg->Flags = Flags; |
| } |
| static inline void capi_fill_DISCONNECT_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr, |
| _cstruct BChannelinformation, |
| _cstruct Keypadfacility, |
| _cstruct Useruserdata, |
| _cstruct Facilitydataarray) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x04, 0x80, Messagenumber, adr); |
| cmsg->BChannelinformation = BChannelinformation; |
| cmsg->Keypadfacility = Keypadfacility; |
| cmsg->Useruserdata = Useruserdata; |
| cmsg->Facilitydataarray = Facilitydataarray; |
| } |
| static inline void capi_fill_DISCONNECT_B3_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr, |
| _cstruct NCPI) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x84, 0x80, Messagenumber, adr); |
| cmsg->NCPI = NCPI; |
| } |
| static inline void capi_fill_MANUFACTURER_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr, |
| __u32 ManuID, |
| __u32 Class, |
| __u32 Function, |
| _cstruct ManuData) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0xff, 0x80, Messagenumber, adr); |
| cmsg->ManuID = ManuID; |
| cmsg->Class = Class; |
| cmsg->Function = Function; |
| cmsg->ManuData = ManuData; |
| } |
| static inline void capi_fill_RESET_B3_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr, |
| _cstruct NCPI) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x87, 0x80, Messagenumber, adr); |
| cmsg->NCPI = NCPI; |
| } |
| static inline void capi_fill_SELECT_B_PROTOCOL_REQ(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr, |
| __u16 B1protocol, |
| __u16 B2protocol, |
| __u16 B3protocol, |
| _cstruct B1configuration, |
| _cstruct B2configuration, |
| _cstruct B3configuration) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x41, 0x80, Messagenumber, adr); |
| cmsg->B1protocol = B1protocol; |
| cmsg->B2protocol = B2protocol; |
| cmsg->B3protocol = B3protocol; |
| cmsg->B1configuration = B1configuration; |
| cmsg->B2configuration = B2configuration; |
| cmsg->B3configuration = B3configuration; |
| } |
| static inline void capi_fill_CONNECT_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr, |
| __u16 Reject, |
| __u16 B1protocol, |
| __u16 B2protocol, |
| __u16 B3protocol, |
| _cstruct B1configuration, |
| _cstruct B2configuration, |
| _cstruct B3configuration, |
| _cstruct ConnectedNumber, |
| _cstruct ConnectedSubaddress, |
| _cstruct LLC, |
| _cstruct BChannelinformation, |
| _cstruct Keypadfacility, |
| _cstruct Useruserdata, |
| _cstruct Facilitydataarray) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x02, 0x83, Messagenumber, adr); |
| cmsg->Reject = Reject; |
| cmsg->B1protocol = B1protocol; |
| cmsg->B2protocol = B2protocol; |
| cmsg->B3protocol = B3protocol; |
| cmsg->B1configuration = B1configuration; |
| cmsg->B2configuration = B2configuration; |
| cmsg->B3configuration = B3configuration; |
| cmsg->ConnectedNumber = ConnectedNumber; |
| cmsg->ConnectedSubaddress = ConnectedSubaddress; |
| cmsg->LLC = LLC; |
| cmsg->BChannelinformation = BChannelinformation; |
| cmsg->Keypadfacility = Keypadfacility; |
| cmsg->Useruserdata = Useruserdata; |
| cmsg->Facilitydataarray = Facilitydataarray; |
| } |
| static inline void capi_fill_CONNECT_ACTIVE_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x03, 0x83, Messagenumber, adr); |
| } |
| static inline void capi_fill_CONNECT_B3_ACTIVE_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x83, 0x83, Messagenumber, adr); |
| } |
| static inline void capi_fill_CONNECT_B3_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr, |
| __u16 Reject, |
| _cstruct NCPI) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x82, 0x83, Messagenumber, adr); |
| cmsg->Reject = Reject; |
| cmsg->NCPI = NCPI; |
| } |
| static inline void capi_fill_CONNECT_B3_T90_ACTIVE_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x88, 0x83, Messagenumber, adr); |
| } |
| static inline void capi_fill_DATA_B3_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr, |
| __u16 DataHandle) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x86, 0x83, Messagenumber, adr); |
| cmsg->DataHandle = DataHandle; |
| } |
| static inline void capi_fill_DISCONNECT_B3_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x84, 0x83, Messagenumber, adr); |
| } |
| static inline void capi_fill_DISCONNECT_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x04, 0x83, Messagenumber, adr); |
| } |
| static inline void capi_fill_FACILITY_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr, |
| __u16 FacilitySelector) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x80, 0x83, Messagenumber, adr); |
| cmsg->FacilitySelector = FacilitySelector; |
| } |
| static inline void capi_fill_INFO_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x08, 0x83, Messagenumber, adr); |
| } |
| static inline void capi_fill_MANUFACTURER_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr, |
| __u32 ManuID, |
| __u32 Class, |
| __u32 Function, |
| _cstruct ManuData) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0xff, 0x83, Messagenumber, adr); |
| cmsg->ManuID = ManuID; |
| cmsg->Class = Class; |
| cmsg->Function = Function; |
| cmsg->ManuData = ManuData; |
| } |
| static inline void capi_fill_RESET_B3_RESP(_cmsg * cmsg, __u16 ApplId, __u16 Messagenumber, |
| __u32 adr) |
| { |
| capi_cmsg_header(cmsg, ApplId, 0x87, 0x83, Messagenumber, adr); |
| } |
| #endif /* __CAPIUTIL_H__ */ |
| /shark/trunk/drivers/linuxc26/include/linux/isdn/capilli.h |
|---|
| 0,0 → 1,97 |
| /* $Id: capilli.h,v 1.1 2004-01-28 15:32:45 giacomo Exp $ |
| * |
| * Kernel CAPI 2.0 Driver Interface for Linux |
| * |
| * Copyright 1999 by Carsten Paeth <calle@calle.de> |
| * |
| * This software may be used and distributed according to the terms |
| * of the GNU General Public License, incorporated herein by reference. |
| * |
| */ |
| #ifndef __CAPILLI_H__ |
| #define __CAPILLI_H__ |
| #include <linux/kernel.h> |
| #include <linux/list.h> |
| #include <linux/capi.h> |
| #include <linux/kernelcapi.h> |
| typedef struct capiloaddatapart { |
| int user; /* data in userspace ? */ |
| int len; |
| unsigned char *data; |
| } capiloaddatapart; |
| typedef struct capiloaddata { |
| capiloaddatapart firmware; |
| capiloaddatapart configuration; |
| } capiloaddata; |
| typedef struct capicardparams { |
| unsigned int port; |
| unsigned irq; |
| int cardtype; |
| int cardnr; |
| unsigned int membase; |
| } capicardparams; |
| struct capi_ctr { |
| /* filled in before calling attach_capi_ctr */ |
| struct module *owner; |
| void *driverdata; /* driver specific */ |
| char name[32]; /* name of controller */ |
| char *driver_name; /* name of driver */ |
| int (*load_firmware)(struct capi_ctr *, capiloaddata *); |
| void (*reset_ctr)(struct capi_ctr *); |
| void (*register_appl)(struct capi_ctr *, u16 appl, |
| capi_register_params *); |
| void (*release_appl)(struct capi_ctr *, u16 appl); |
| u16 (*send_message)(struct capi_ctr *, struct sk_buff *skb); |
| char *(*procinfo)(struct capi_ctr *); |
| int (*ctr_read_proc)(char *page, char **start, off_t off, |
| int count, int *eof, struct capi_ctr *card); |
| /* filled in before calling ready callback */ |
| u8 manu[CAPI_MANUFACTURER_LEN]; /* CAPI_GET_MANUFACTURER */ |
| capi_version version; /* CAPI_GET_VERSION */ |
| capi_profile profile; /* CAPI_GET_PROFILE */ |
| u8 serial[CAPI_SERIAL_LEN]; /* CAPI_GET_SERIAL */ |
| /* management information for kcapi */ |
| unsigned long nrecvctlpkt; |
| unsigned long nrecvdatapkt; |
| unsigned long nsentctlpkt; |
| unsigned long nsentdatapkt; |
| int cnr; /* controller number */ |
| volatile unsigned short cardstate; /* controller state */ |
| volatile int blocked; /* output blocked */ |
| int traceflag; /* capi trace */ |
| struct proc_dir_entry *procent; |
| char procfn[128]; |
| }; |
| int attach_capi_ctr(struct capi_ctr *); |
| int detach_capi_ctr(struct capi_ctr *); |
| void capi_ctr_ready(struct capi_ctr * card); |
| void capi_ctr_reseted(struct capi_ctr * card); |
| void capi_ctr_suspend_output(struct capi_ctr * card); |
| void capi_ctr_resume_output(struct capi_ctr * card); |
| void capi_ctr_handle_message(struct capi_ctr * card, u16 appl, struct sk_buff *skb); |
| // --------------------------------------------------------------------------- |
| // library functions for use by hardware controller drivers |
| void capilib_new_ncci(struct list_head *head, u16 applid, u32 ncci, u32 winsize); |
| void capilib_free_ncci(struct list_head *head, u16 applid, u32 ncci); |
| void capilib_release_appl(struct list_head *head, u16 applid); |
| void capilib_release(struct list_head *head); |
| void capilib_data_b3_conf(struct list_head *head, u16 applid, u32 ncci, u16 msgid); |
| u16 capilib_data_b3_req(struct list_head *head, u16 applid, u32 ncci, u16 msgid); |
| #endif /* __CAPILLI_H__ */ |
| /shark/trunk/drivers/linuxc26/include/linux/isdn/capicmd.h |
|---|
| 0,0 → 1,115 |
| /* $Id: capicmd.h,v 1.1 2004-01-28 15:32:45 giacomo Exp $ |
| * |
| * CAPI 2.0 Interface for Linux |
| * |
| * Copyright 1997 by Carsten Paeth <calle@calle.de> |
| * |
| * This software may be used and distributed according to the terms |
| * of the GNU General Public License, incorporated herein by reference. |
| * |
| */ |
| #ifndef __CAPICMD_H__ |
| #define __CAPICMD_H__ |
| #define CAPI_MSG_BASELEN 8 |
| #define CAPI_DATA_B3_REQ_LEN (CAPI_MSG_BASELEN+4+4+2+2+2) |
| #define CAPI_DATA_B3_RESP_LEN (CAPI_MSG_BASELEN+4+2) |
| /*----- CAPI commands -----*/ |
| #define CAPI_ALERT 0x01 |
| #define CAPI_CONNECT 0x02 |
| #define CAPI_CONNECT_ACTIVE 0x03 |
| #define CAPI_CONNECT_B3_ACTIVE 0x83 |
| #define CAPI_CONNECT_B3 0x82 |
| #define CAPI_CONNECT_B3_T90_ACTIVE 0x88 |
| #define CAPI_DATA_B3 0x86 |
| #define CAPI_DISCONNECT_B3 0x84 |
| #define CAPI_DISCONNECT 0x04 |
| #define CAPI_FACILITY 0x80 |
| #define CAPI_INFO 0x08 |
| #define CAPI_LISTEN 0x05 |
| #define CAPI_MANUFACTURER 0xff |
| #define CAPI_RESET_B3 0x87 |
| #define CAPI_SELECT_B_PROTOCOL 0x41 |
| /*----- CAPI subcommands -----*/ |
| #define CAPI_REQ 0x80 |
| #define CAPI_CONF 0x81 |
| #define CAPI_IND 0x82 |
| #define CAPI_RESP 0x83 |
| /*----- CAPI combined commands -----*/ |
| #define CAPICMD(cmd,subcmd) (((cmd)<<8)|(subcmd)) |
| #define CAPI_DISCONNECT_REQ CAPICMD(CAPI_DISCONNECT,CAPI_REQ) |
| #define CAPI_DISCONNECT_CONF CAPICMD(CAPI_DISCONNECT,CAPI_CONF) |
| #define CAPI_DISCONNECT_IND CAPICMD(CAPI_DISCONNECT,CAPI_IND) |
| #define CAPI_DISCONNECT_RESP CAPICMD(CAPI_DISCONNECT,CAPI_RESP) |
| #define CAPI_ALERT_REQ CAPICMD(CAPI_ALERT,CAPI_REQ) |
| #define CAPI_ALERT_CONF CAPICMD(CAPI_ALERT,CAPI_CONF) |
| #define CAPI_CONNECT_REQ CAPICMD(CAPI_CONNECT,CAPI_REQ) |
| #define CAPI_CONNECT_CONF CAPICMD(CAPI_CONNECT,CAPI_CONF) |
| #define CAPI_CONNECT_IND CAPICMD(CAPI_CONNECT,CAPI_IND) |
| #define CAPI_CONNECT_RESP CAPICMD(CAPI_CONNECT,CAPI_RESP) |
| #define CAPI_CONNECT_ACTIVE_REQ CAPICMD(CAPI_CONNECT_ACTIVE,CAPI_REQ) |
| #define CAPI_CONNECT_ACTIVE_CONF CAPICMD(CAPI_CONNECT_ACTIVE,CAPI_CONF) |
| #define CAPI_CONNECT_ACTIVE_IND CAPICMD(CAPI_CONNECT_ACTIVE,CAPI_IND) |
| #define CAPI_CONNECT_ACTIVE_RESP CAPICMD(CAPI_CONNECT_ACTIVE,CAPI_RESP) |
| #define CAPI_SELECT_B_PROTOCOL_REQ CAPICMD(CAPI_SELECT_B_PROTOCOL,CAPI_REQ) |
| #define CAPI_SELECT_B_PROTOCOL_CONF CAPICMD(CAPI_SELECT_B_PROTOCOL,CAPI_CONF) |
| #define CAPI_CONNECT_B3_ACTIVE_REQ CAPICMD(CAPI_CONNECT_B3_ACTIVE,CAPI_REQ) |
| #define CAPI_CONNECT_B3_ACTIVE_CONF CAPICMD(CAPI_CONNECT_B3_ACTIVE,CAPI_CONF) |
| #define CAPI_CONNECT_B3_ACTIVE_IND CAPICMD(CAPI_CONNECT_B3_ACTIVE,CAPI_IND) |
| #define CAPI_CONNECT_B3_ACTIVE_RESP CAPICMD(CAPI_CONNECT_B3_ACTIVE,CAPI_RESP) |
| #define CAPI_CONNECT_B3_REQ CAPICMD(CAPI_CONNECT_B3,CAPI_REQ) |
| #define CAPI_CONNECT_B3_CONF CAPICMD(CAPI_CONNECT_B3,CAPI_CONF) |
| #define CAPI_CONNECT_B3_IND CAPICMD(CAPI_CONNECT_B3,CAPI_IND) |
| #define CAPI_CONNECT_B3_RESP CAPICMD(CAPI_CONNECT_B3,CAPI_RESP) |
| #define CAPI_CONNECT_B3_T90_ACTIVE_IND CAPICMD(CAPI_CONNECT_B3_T90_ACTIVE,CAPI_IND) |
| #define CAPI_CONNECT_B3_T90_ACTIVE_RESP CAPICMD(CAPI_CONNECT_B3_T90_ACTIVE,CAPI_RESP) |
| #define CAPI_DATA_B3_REQ CAPICMD(CAPI_DATA_B3,CAPI_REQ) |
| #define CAPI_DATA_B3_CONF CAPICMD(CAPI_DATA_B3,CAPI_CONF) |
| #define CAPI_DATA_B3_IND CAPICMD(CAPI_DATA_B3,CAPI_IND) |
| #define CAPI_DATA_B3_RESP CAPICMD(CAPI_DATA_B3,CAPI_RESP) |
| #define CAPI_DISCONNECT_B3_REQ CAPICMD(CAPI_DISCONNECT_B3,CAPI_REQ) |
| #define CAPI_DISCONNECT_B3_CONF CAPICMD(CAPI_DISCONNECT_B3,CAPI_CONF) |
| #define CAPI_DISCONNECT_B3_IND CAPICMD(CAPI_DISCONNECT_B3,CAPI_IND) |
| #define CAPI_DISCONNECT_B3_RESP CAPICMD(CAPI_DISCONNECT_B3,CAPI_RESP) |
| #define CAPI_RESET_B3_REQ CAPICMD(CAPI_RESET_B3,CAPI_REQ) |
| #define CAPI_RESET_B3_CONF CAPICMD(CAPI_RESET_B3,CAPI_CONF) |
| #define CAPI_RESET_B3_IND CAPICMD(CAPI_RESET_B3,CAPI_IND) |
| #define CAPI_RESET_B3_RESP CAPICMD(CAPI_RESET_B3,CAPI_RESP) |
| #define CAPI_LISTEN_REQ CAPICMD(CAPI_LISTEN,CAPI_REQ) |
| #define CAPI_LISTEN_CONF CAPICMD(CAPI_LISTEN,CAPI_CONF) |
| #define CAPI_MANUFACTURER_REQ CAPICMD(CAPI_MANUFACTURER,CAPI_REQ) |
| #define CAPI_MANUFACTURER_CONF CAPICMD(CAPI_MANUFACTURER,CAPI_CONF) |
| #define CAPI_MANUFACTURER_IND CAPICMD(CAPI_MANUFACTURER,CAPI_IND) |
| #define CAPI_MANUFACTURER_RESP CAPICMD(CAPI_MANUFACTURER,CAPI_RESP) |
| #define CAPI_FACILITY_REQ CAPICMD(CAPI_FACILITY,CAPI_REQ) |
| #define CAPI_FACILITY_CONF CAPICMD(CAPI_FACILITY,CAPI_CONF) |
| #define CAPI_FACILITY_IND CAPICMD(CAPI_FACILITY,CAPI_IND) |
| #define CAPI_FACILITY_RESP CAPICMD(CAPI_FACILITY,CAPI_RESP) |
| #define CAPI_INFO_REQ CAPICMD(CAPI_INFO,CAPI_REQ) |
| #define CAPI_INFO_CONF CAPICMD(CAPI_INFO,CAPI_CONF) |
| #define CAPI_INFO_IND CAPICMD(CAPI_INFO,CAPI_IND) |
| #define CAPI_INFO_RESP CAPICMD(CAPI_INFO,CAPI_RESP) |
| #endif /* __CAPICMD_H__ */ |
| /shark/trunk/drivers/linuxc26/include/linux/isdn/tpam.h |
|---|
| 0,0 → 1,56 |
| /* $Id: tpam.h,v 1.1 2004-01-28 15:32:46 giacomo Exp $ |
| * |
| * Turbo PAM ISDN driver for Linux. (Kernel Driver) |
| * |
| * Copyright 2001 Stelian Pop <stelian.pop@fr.alcove.com>, Alcôve |
| * |
| * For all support questions please contact: <support@auvertech.fr> |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2, or (at your option) |
| * any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| * |
| */ |
| #ifndef _TPAM_H_ |
| #define _TPAM_H_ |
| #include <linux/types.h> |
| #include <linux/pci.h> |
| /* IOCTL commands */ |
| #define TPAM_CMD_DSPLOAD 0x0001 |
| #define TPAM_CMD_DSPSAVE 0x0002 |
| #define TPAM_CMD_DSPRUN 0x0003 |
| #define TPAM_CMD_LOOPMODEON 0x0004 |
| #define TPAM_CMD_LOOPMODEOFF 0x0005 |
| /* addresses of debug information zones on board */ |
| #define TPAM_TRAPAUDIT_REGISTER 0x005493e4 |
| #define TPAM_NCOAUDIT_REGISTER 0x00500000 |
| #define TPAM_MSGAUDIT_REGISTER 0x008E30F0 |
| /* length of debug information zones on board */ |
| #define TPAM_TRAPAUDIT_LENGTH 10000 |
| #define TPAM_NCOAUDIT_LENGTH 300000 |
| #define TPAM_NCOAUDIT_COUNT 30 |
| #define TPAM_MSGAUDIT_LENGTH 60000 |
| /* IOCTL load/save parameter */ |
| typedef struct tpam_dsp_ioctl { |
| __u32 address; /* address to load/save data */ |
| __u32 data_len; /* size of data to be loaded/saved */ |
| __u8 data[0]; /* data */ |
| } tpam_dsp_ioctl; |
| #endif /* _TPAM_H_ */ |
| /shark/trunk/drivers/linuxc26/include/linux/isdn/fsm.h |
|---|
| 0,0 → 1,58 |
| /* Linux ISDN subsystem, finite state machine |
| * |
| * Author Karsten Keil |
| * Copyright by Karsten Keil <keil@isdn4linux.de> |
| * 2001-2002 by Kai Germaschewski <kai@germaschewski.name> |
| * |
| * This software may be used and distributed according to the terms |
| * of the GNU General Public License, incorporated herein by reference. |
| */ |
| #ifndef __ISDN_FSM_H__ |
| #define __ISDN_FSM_H__ |
| #include <linux/kernel.h> |
| #include <linux/timer.h> |
| struct fsm_inst; |
| typedef int (*fsm_fn)(struct fsm_inst *, int, void *); |
| struct fsm { |
| fsm_fn *jumpmatrix; |
| int st_cnt, ev_cnt, fn_cnt; |
| char **st_str, **ev_str; |
| struct fsm_node *fn_tbl; |
| }; |
| struct fsm_inst { |
| struct fsm *fsm; |
| int state; |
| int debug; |
| void *userdata; |
| int userint; |
| void (*printdebug) (struct fsm_inst *, char *, ...); |
| }; |
| struct fsm_node { |
| int st, ev; |
| fsm_fn fn; |
| }; |
| struct fsm_timer { |
| struct fsm_inst *fi; |
| struct timer_list tl; |
| int ev; |
| void *arg; |
| }; |
| int fsm_new(struct fsm *fsm); |
| void fsm_free(struct fsm *fsm); |
| int fsm_event(struct fsm_inst *fi, int event, void *arg); |
| void fsm_change_state(struct fsm_inst *fi, int newstate); |
| void fsm_init_timer(struct fsm_inst *fi, struct fsm_timer *ft); |
| int fsm_add_timer(struct fsm_timer *ft, int timeout, int event); |
| void fsm_mod_timer(struct fsm_timer *ft, int timeout, int event); |
| void fsm_del_timer(struct fsm_timer *ft); |
| #endif |
| /shark/trunk/drivers/linuxc26/include/linux/hdlc/ioctl.h |
|---|
| 0,0 → 1,48 |
| #ifndef __HDLC_IOCTL_H__ |
| #define __HDLC_IOCTL_H__ |
| typedef struct { |
| unsigned int clock_rate; /* bits per second */ |
| unsigned int clock_type; /* internal, external, TX-internal etc. */ |
| unsigned short loopback; |
| } sync_serial_settings; /* V.35, V.24, X.21 */ |
| typedef struct { |
| unsigned int clock_rate; /* bits per second */ |
| unsigned int clock_type; /* internal, external, TX-internal etc. */ |
| unsigned short loopback; |
| unsigned int slot_map; |
| } te1_settings; /* T1, E1 */ |
| typedef struct { |
| unsigned short encoding; |
| unsigned short parity; |
| } raw_hdlc_proto; |
| typedef struct { |
| unsigned int t391; |
| unsigned int t392; |
| unsigned int n391; |
| unsigned int n392; |
| unsigned int n393; |
| unsigned short lmi; |
| unsigned short dce; /* 1 for DCE (network side) operation */ |
| } fr_proto; |
| typedef struct { |
| unsigned int dlci; |
| } fr_proto_pvc; /* for creating/deleting FR PVCs */ |
| typedef struct { |
| unsigned int dlci; |
| char master[IFNAMSIZ]; /* Name of master FRAD device */ |
| }fr_proto_pvc_info; /* for returning PVC information only */ |
| typedef struct { |
| unsigned int interval; |
| unsigned int timeout; |
| } cisco_proto; |
| /* PPP doesn't need any info now - supply length = 0 to ioctl */ |
| #endif /* __HDLC_IOCTL_H__ */ |
| /shark/trunk/drivers/linuxc26/include/linux/lockd/bind.h |
|---|
| 0,0 → 1,36 |
| /* |
| * linux/include/linux/lockd/bind.h |
| * |
| * This is the part of lockd visible to nfsd and the nfs client. |
| * |
| * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de> |
| */ |
| #ifndef LINUX_LOCKD_BIND_H |
| #define LINUX_LOCKD_BIND_H |
| #include <linux/lockd/nlm.h> |
| /* Dummy declarations */ |
| struct svc_rqst; |
| /* |
| * This is the set of functions for lockd->nfsd communication |
| */ |
| struct nlmsvc_binding { |
| u32 (*fopen)(struct svc_rqst *, |
| struct nfs_fh *, |
| struct file *); |
| void (*fclose)(struct file *); |
| }; |
| extern struct nlmsvc_binding * nlmsvc_ops; |
| /* |
| * Functions exported by the lockd module |
| */ |
| extern int nlmclnt_proc(struct inode *, int, struct file_lock *); |
| extern int lockd_up(void); |
| extern void lockd_down(void); |
| #endif /* LINUX_LOCKD_BIND_H */ |
| /shark/trunk/drivers/linuxc26/include/linux/lockd/lockd.h |
|---|
| 0,0 → 1,209 |
| /* |
| * linux/include/linux/lockd/lockd.h |
| * |
| * General-purpose lockd include file. |
| * |
| * Copyright (C) 1996 Olaf Kirch <okir@monad.swb.de> |
| */ |
| #ifndef LINUX_LOCKD_LOCKD_H |
| #define LINUX_LOCKD_LOCKD_H |
| #ifdef __KERNEL__ |
| #include <linux/config.h> |
| #include <linux/in.h> |
| #include <linux/fs.h> |
| #include <linux/utsname.h> |
| #include <linux/nfsd/nfsfh.h> |
| #include <linux/lockd/bind.h> |
| #include <linux/lockd/xdr.h> |
| #ifdef CONFIG_LOCKD_V4 |
| #include <linux/lockd/xdr4.h> |
| #endif |
| #include <linux/lockd/debug.h> |
| /* |
| * Version string |
| */ |
| #define LOCKD_VERSION "0.5" |
| /* |
| * Default timeout for RPC calls (seconds) |
| */ |
| #define LOCKD_DFLT_TIMEO 10 |
| /* |
| * Lockd host handle (used both by the client and server personality). |
| */ |
| struct nlm_host { |
| struct nlm_host * h_next; /* linked list (hash table) */ |
| struct sockaddr_in h_addr; /* peer address */ |
| struct rpc_clnt * h_rpcclnt; /* RPC client to talk to peer */ |
| char h_name[20]; /* remote hostname */ |
| u32 h_version; /* interface version */ |
| rpc_authflavor_t h_authflavor; /* RPC authentication type */ |
| unsigned short h_proto; /* transport proto */ |
| unsigned short h_reclaiming : 1, |
| h_server : 1, /* server side, not client side */ |
| h_inuse : 1, |
| h_killed : 1, |
| h_monitored : 1; |
| wait_queue_head_t h_gracewait; /* wait while reclaiming */ |
| u32 h_state; /* pseudo-state counter */ |
| u32 h_nsmstate; /* true remote NSM state */ |
| unsigned int h_count; /* reference count */ |
| struct semaphore h_sema; /* mutex for pmap binding */ |
| unsigned long h_nextrebind; /* next portmap call */ |
| unsigned long h_expires; /* eligible for GC */ |
| }; |
| /* |
| * Memory chunk for NLM client RPC request. |
| */ |
| #define NLMCLNT_OHSIZE (sizeof(system_utsname.nodename)+10) |
| struct nlm_rqst { |
| unsigned int a_flags; /* initial RPC task flags */ |
| struct nlm_host * a_host; /* host handle */ |
| struct nlm_args a_args; /* arguments */ |
| struct nlm_res a_res; /* result */ |
| char a_owner[NLMCLNT_OHSIZE]; |
| }; |
| /* |
| * This struct describes a file held open by lockd on behalf of |
| * an NFS client. |
| */ |
| struct nlm_file { |
| struct nlm_file * f_next; /* linked list */ |
| struct nfs_fh f_handle; /* NFS file handle */ |
| struct file f_file; /* VFS file pointer */ |
| struct nlm_share * f_shares; /* DOS shares */ |
| struct nlm_block * f_blocks; /* blocked locks */ |
| unsigned int f_locks; /* guesstimate # of locks */ |
| unsigned int f_count; /* reference count */ |
| struct semaphore f_sema; /* avoid concurrent access */ |
| int f_hash; /* hash of f_handle */ |
| }; |
| /* |
| * This is a server block (i.e. a lock requested by some client which |
| * couldn't be granted because of a conflicting lock). |
| */ |
| #define NLM_NEVER (~(unsigned long) 0) |
| struct nlm_block { |
| struct nlm_block * b_next; /* linked list (all blocks) */ |
| struct nlm_block * b_fnext; /* linked list (per file) */ |
| struct nlm_rqst b_call; /* RPC args & callback info */ |
| struct svc_serv * b_daemon; /* NLM service */ |
| struct nlm_host * b_host; /* host handle for RPC clnt */ |
| unsigned long b_when; /* next re-xmit */ |
| unsigned int b_id; /* block id */ |
| unsigned char b_queued; /* re-queued */ |
| unsigned char b_granted; /* VFS granted lock */ |
| unsigned char b_incall; /* doing callback */ |
| unsigned char b_done; /* callback complete */ |
| struct nlm_file * b_file; /* file in question */ |
| }; |
| /* |
| * Valid actions for nlmsvc_traverse_files |
| */ |
| #define NLM_ACT_CHECK 0 /* check for locks */ |
| #define NLM_ACT_MARK 1 /* mark & sweep */ |
| #define NLM_ACT_UNLOCK 2 /* release all locks */ |
| /* |
| * Global variables |
| */ |
| extern struct rpc_program nlm_program; |
| extern struct svc_procedure nlmsvc_procedures[]; |
| #ifdef CONFIG_LOCKD_V4 |
| extern struct svc_procedure nlmsvc_procedures4[]; |
| #endif |
| extern int nlmsvc_grace_period; |
| extern unsigned long nlmsvc_timeout; |
| /* |
| * Lockd client functions |
| */ |
| struct nlm_rqst * nlmclnt_alloc_call(void); |
| int nlmclnt_call(struct nlm_rqst *, u32); |
| int nlmclnt_async_call(struct nlm_rqst *, u32, rpc_action); |
| int nlmclnt_block(struct nlm_host *, struct file_lock *, u32 *); |
| int nlmclnt_cancel(struct nlm_host *, struct file_lock *); |
| u32 nlmclnt_grant(struct nlm_lock *); |
| void nlmclnt_recovery(struct nlm_host *, u32); |
| int nlmclnt_reclaim(struct nlm_host *, struct file_lock *); |
| int nlmclnt_setgrantargs(struct nlm_rqst *, struct nlm_lock *); |
| void nlmclnt_freegrantargs(struct nlm_rqst *); |
| /* |
| * Host cache |
| */ |
| struct nlm_host * nlmclnt_lookup_host(struct sockaddr_in *, int, int); |
| struct nlm_host * nlmsvc_lookup_host(struct svc_rqst *); |
| struct nlm_host * nlm_lookup_host(int server, struct sockaddr_in *, int, int); |
| struct rpc_clnt * nlm_bind_host(struct nlm_host *); |
| void nlm_rebind_host(struct nlm_host *); |
| struct nlm_host * nlm_get_host(struct nlm_host *); |
| void nlm_release_host(struct nlm_host *); |
| void nlm_shutdown_hosts(void); |
| extern struct nlm_host *nlm_find_client(void); |
| /* |
| * Server-side lock handling |
| */ |
| int nlmsvc_async_call(struct nlm_rqst *, u32, rpc_action); |
| u32 nlmsvc_lock(struct svc_rqst *, struct nlm_file *, |
| struct nlm_lock *, int, struct nlm_cookie *); |
| u32 nlmsvc_unlock(struct nlm_file *, struct nlm_lock *); |
| u32 nlmsvc_testlock(struct nlm_file *, struct nlm_lock *, |
| struct nlm_lock *); |
| u32 nlmsvc_cancel_blocked(struct nlm_file *, struct nlm_lock *); |
| unsigned long nlmsvc_retry_blocked(void); |
| int nlmsvc_traverse_blocks(struct nlm_host *, struct nlm_file *, |
| int action); |
| /* |
| * File handling for the server personality |
| */ |
| u32 nlm_lookup_file(struct svc_rqst *, struct nlm_file **, |
| struct nfs_fh *); |
| void nlm_release_file(struct nlm_file *); |
| void nlmsvc_mark_resources(void); |
| void nlmsvc_free_host_resources(struct nlm_host *); |
| void nlmsvc_invalidate_all(void); |
| static __inline__ struct inode * |
| nlmsvc_file_inode(struct nlm_file *file) |
| { |
| return file->f_file.f_dentry->d_inode; |
| } |
| /* |
| * Compare two host addresses (needs modifying for ipv6) |
| */ |
| static __inline__ int |
| nlm_cmp_addr(struct sockaddr_in *sin1, struct sockaddr_in *sin2) |
| { |
| return sin1->sin_addr.s_addr == sin2->sin_addr.s_addr; |
| } |
| /* |
| * Compare two NLM locks. |
| * When the second lock is of type F_UNLCK, this acts like a wildcard. |
| */ |
| static __inline__ int |
| nlm_compare_locks(struct file_lock *fl1, struct file_lock *fl2) |
| { |
| return fl1->fl_pid == fl2->fl_pid |
| && fl1->fl_start == fl2->fl_start |
| && fl1->fl_end == fl2->fl_end |
| &&(fl1->fl_type == fl2->fl_type || fl2->fl_type == F_UNLCK); |
| } |
| #endif /* __KERNEL__ */ |
| #endif /* LINUX_LOCKD_LOCKD_H */ |
| /shark/trunk/drivers/linuxc26/include/linux/lockd/xdr.h |
|---|
| 0,0 → 1,108 |
| /* |
| * linux/include/linux/lockd/xdr.h |
| * |
| * XDR types for the NLM protocol |
| * |
| * Copyright (C) 1996 Olaf Kirch <okir@monad.swb.de> |
| */ |
| #ifndef LOCKD_XDR_H |
| #define LOCKD_XDR_H |
| #include <linux/fs.h> |
| #include <linux/nfs.h> |
| #include <linux/sunrpc/xdr.h> |
| #define NLM_MAXSTRLEN 1024 |
| #define QUADLEN(len) (((len) + 3) >> 2) |
| #define nlm_granted __constant_htonl(NLM_LCK_GRANTED) |
| #define nlm_lck_denied __constant_htonl(NLM_LCK_DENIED) |
| #define nlm_lck_denied_nolocks __constant_htonl(NLM_LCK_DENIED_NOLOCKS) |
| #define nlm_lck_blocked __constant_htonl(NLM_LCK_BLOCKED) |
| #define nlm_lck_denied_grace_period __constant_htonl(NLM_LCK_DENIED_GRACE_PERIOD) |
| /* Lock info passed via NLM */ |
| struct nlm_lock { |
| char * caller; |
| int len; /* length of "caller" */ |
| struct nfs_fh fh; |
| struct xdr_netobj oh; |
| struct file_lock fl; |
| }; |
| /* |
| * NLM cookies. Technically they can be 1K, Nobody uses over 8 bytes |
| * however. |
| */ |
| struct nlm_cookie |
| { |
| unsigned char data[8]; |
| unsigned int len; |
| }; |
| /* |
| * Generic lockd arguments for all but sm_notify |
| */ |
| struct nlm_args { |
| struct nlm_cookie cookie; |
| struct nlm_lock lock; |
| u32 block; |
| u32 reclaim; |
| u32 state; |
| u32 monitor; |
| u32 fsm_access; |
| u32 fsm_mode; |
| }; |
| typedef struct nlm_args nlm_args; |
| /* |
| * Generic lockd result |
| */ |
| struct nlm_res { |
| struct nlm_cookie cookie; |
| u32 status; |
| struct nlm_lock lock; |
| }; |
| /* |
| * statd callback when client has rebooted |
| */ |
| struct nlm_reboot { |
| char * mon; |
| int len; |
| u32 state; |
| u32 addr; |
| u32 vers; |
| u32 proto; |
| }; |
| /* |
| * Contents of statd callback when monitored host rebooted |
| */ |
| #define NLMSVC_XDRSIZE sizeof(struct nlm_args) |
| int nlmsvc_decode_testargs(struct svc_rqst *, u32 *, struct nlm_args *); |
| int nlmsvc_encode_testres(struct svc_rqst *, u32 *, struct nlm_res *); |
| int nlmsvc_decode_lockargs(struct svc_rqst *, u32 *, struct nlm_args *); |
| int nlmsvc_decode_cancargs(struct svc_rqst *, u32 *, struct nlm_args *); |
| int nlmsvc_decode_unlockargs(struct svc_rqst *, u32 *, struct nlm_args *); |
| int nlmsvc_encode_res(struct svc_rqst *, u32 *, struct nlm_res *); |
| int nlmsvc_decode_res(struct svc_rqst *, u32 *, struct nlm_res *); |
| int nlmsvc_encode_void(struct svc_rqst *, u32 *, void *); |
| int nlmsvc_decode_void(struct svc_rqst *, u32 *, void *); |
| int nlmsvc_decode_shareargs(struct svc_rqst *, u32 *, struct nlm_args *); |
| int nlmsvc_encode_shareres(struct svc_rqst *, u32 *, struct nlm_res *); |
| int nlmsvc_decode_notify(struct svc_rqst *, u32 *, struct nlm_args *); |
| int nlmsvc_decode_reboot(struct svc_rqst *, u32 *, struct nlm_reboot *); |
| /* |
| int nlmclt_encode_testargs(struct rpc_rqst *, u32 *, struct nlm_args *); |
| int nlmclt_encode_lockargs(struct rpc_rqst *, u32 *, struct nlm_args *); |
| int nlmclt_encode_cancargs(struct rpc_rqst *, u32 *, struct nlm_args *); |
| int nlmclt_encode_unlockargs(struct rpc_rqst *, u32 *, struct nlm_args *); |
| */ |
| #endif /* LOCKD_XDR_H */ |
| /shark/trunk/drivers/linuxc26/include/linux/lockd/sm_inter.h |
|---|
| 0,0 → 1,46 |
| /* |
| * linux/include/linux/lockd/sm_inter.h |
| * |
| * Declarations for the kernel statd client. |
| * |
| * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de> |
| */ |
| #ifndef LINUX_LOCKD_SM_INTER_H |
| #define LINUX_LOCKD_SM_INTER_H |
| #define SM_PROGRAM 100024 |
| #define SM_VERSION 1 |
| #define SM_STAT 1 |
| #define SM_MON 2 |
| #define SM_UNMON 3 |
| #define SM_UNMON_ALL 4 |
| #define SM_SIMU_CRASH 5 |
| #define SM_NOTIFY 6 |
| #define SM_MAXSTRLEN 1024 |
| /* |
| * Arguments for all calls to statd |
| */ |
| struct nsm_args { |
| u32 addr; /* remote address */ |
| u32 prog; /* RPC callback info */ |
| u32 vers; |
| u32 proc; |
| u32 proto; /* protocol (udp/tcp) plus server/client flag */ |
| }; |
| /* |
| * Result returned by statd |
| */ |
| struct nsm_res { |
| u32 status; |
| u32 state; |
| }; |
| int nsm_monitor(struct nlm_host *); |
| int nsm_unmonitor(struct nlm_host *); |
| extern u32 nsm_local_state; |
| #endif /* LINUX_LOCKD_SM_INTER_H */ |
| /shark/trunk/drivers/linuxc26/include/linux/lockd/xdr4.h |
|---|
| 0,0 → 1,46 |
| /* |
| * linux/include/linux/lockd/xdr.h |
| * |
| * XDR types for the NLM protocol |
| * |
| * Copyright (C) 1996 Olaf Kirch <okir@monad.swb.de> |
| */ |
| #ifndef LOCKD_XDR4_H |
| #define LOCKD_XDR4_H |
| #include <linux/fs.h> |
| #include <linux/nfs.h> |
| #include <linux/sunrpc/xdr.h> |
| #include <linux/lockd/xdr.h> |
| /* error codes new to NLMv4 */ |
| #define nlm4_deadlock __constant_htonl(NLM_DEADLCK) |
| #define nlm4_rofs __constant_htonl(NLM_ROFS) |
| #define nlm4_stale_fh __constant_htonl(NLM_STALE_FH) |
| #define nlm4_fbig __constant_htonl(NLM_FBIG) |
| #define nlm4_failed __constant_htonl(NLM_FAILED) |
| int nlm4svc_decode_testargs(struct svc_rqst *, u32 *, struct nlm_args *); |
| int nlm4svc_encode_testres(struct svc_rqst *, u32 *, struct nlm_res *); |
| int nlm4svc_decode_lockargs(struct svc_rqst *, u32 *, struct nlm_args *); |
| int nlm4svc_decode_cancargs(struct svc_rqst *, u32 *, struct nlm_args *); |
| int nlm4svc_decode_unlockargs(struct svc_rqst *, u32 *, struct nlm_args *); |
| int nlm4svc_encode_res(struct svc_rqst *, u32 *, struct nlm_res *); |
| int nlm4svc_decode_res(struct svc_rqst *, u32 *, struct nlm_res *); |
| int nlm4svc_encode_void(struct svc_rqst *, u32 *, void *); |
| int nlm4svc_decode_void(struct svc_rqst *, u32 *, void *); |
| int nlm4svc_decode_shareargs(struct svc_rqst *, u32 *, struct nlm_args *); |
| int nlm4svc_encode_shareres(struct svc_rqst *, u32 *, struct nlm_res *); |
| int nlm4svc_decode_notify(struct svc_rqst *, u32 *, struct nlm_args *); |
| int nlm4svc_decode_reboot(struct svc_rqst *, u32 *, struct nlm_reboot *); |
| /* |
| int nlmclt_encode_testargs(struct rpc_rqst *, u32 *, struct nlm_args *); |
| int nlmclt_encode_lockargs(struct rpc_rqst *, u32 *, struct nlm_args *); |
| int nlmclt_encode_cancargs(struct rpc_rqst *, u32 *, struct nlm_args *); |
| int nlmclt_encode_unlockargs(struct rpc_rqst *, u32 *, struct nlm_args *); |
| */ |
| #endif /* LOCKD_XDR4_H */ |
| /shark/trunk/drivers/linuxc26/include/linux/lockd/share.h |
|---|
| 0,0 → 1,30 |
| /* |
| * linux/include/linux/lockd/share.h |
| * |
| * DOS share management for lockd. |
| * |
| * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de> |
| */ |
| #ifndef LINUX_LOCKD_SHARE_H |
| #define LINUX_LOCKD_SHARE_H |
| /* |
| * DOS share for a specific file |
| */ |
| struct nlm_share { |
| struct nlm_share * s_next; /* linked list */ |
| struct nlm_host * s_host; /* client host */ |
| struct nlm_file * s_file; /* shared file */ |
| struct xdr_netobj s_owner; /* owner handle */ |
| u32 s_access; /* access mode */ |
| u32 s_mode; /* deny mode */ |
| }; |
| u32 nlmsvc_share_file(struct nlm_host *, struct nlm_file *, |
| struct nlm_args *); |
| u32 nlmsvc_unshare_file(struct nlm_host *, struct nlm_file *, |
| struct nlm_args *); |
| int nlmsvc_traverse_shares(struct nlm_host *, struct nlm_file *, int); |
| #endif /* LINUX_LOCKD_SHARE_H */ |
| /shark/trunk/drivers/linuxc26/include/linux/lockd/debug.h |
|---|
| 0,0 → 1,48 |
| /* |
| * linux/include/linux/lockd/debug.h |
| * |
| * Debugging stuff. |
| * |
| * Copyright (C) 1996 Olaf Kirch <okir@monad.swb.de> |
| */ |
| #ifndef LINUX_LOCKD_DEBUG_H |
| #define LINUX_LOCKD_DEBUG_H |
| #ifdef __KERNEL__ |
| #include <linux/sunrpc/debug.h> |
| /* |
| * Enable lockd debugging. |
| * Requires RPC_DEBUG. |
| */ |
| #ifdef RPC_DEBUG |
| # define LOCKD_DEBUG 1 |
| #endif |
| #undef ifdebug |
| #if defined(RPC_DEBUG) && defined(LOCKD_DEBUG) |
| # define ifdebug(flag) if (nlm_debug & NLMDBG_##flag) |
| #else |
| # define ifdebug(flag) if (0) |
| #endif |
| #endif /* __KERNEL__ */ |
| /* |
| * Debug flags |
| */ |
| #define NLMDBG_SVC 0x0001 |
| #define NLMDBG_CLIENT 0x0002 |
| #define NLMDBG_CLNTLOCK 0x0004 |
| #define NLMDBG_SVCLOCK 0x0008 |
| #define NLMDBG_MONITOR 0x0010 |
| #define NLMDBG_CLNTSUBS 0x0020 |
| #define NLMDBG_SVCSUBS 0x0040 |
| #define NLMDBG_HOSTCACHE 0x0080 |
| #define NLMDBG_XDR 0x0100 |
| #define NLMDBG_ALL 0x7fff |
| #endif /* LINUX_LOCKD_DEBUG_H */ |
| /shark/trunk/drivers/linuxc26/include/linux/lockd/nlm.h |
|---|
| 0,0 → 1,58 |
| /* |
| * linux/include/linux/lockd/nlm.h |
| * |
| * Declarations for the Network Lock Manager protocol. |
| * |
| * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de> |
| */ |
| #ifndef LINUX_LOCKD_NLM_H |
| #define LINUX_LOCKD_NLM_H |
| #include <linux/config.h> |
| /* Maximum file offset in file_lock.fl_end */ |
| # define NLM_OFFSET_MAX ((s32) 0x7fffffff) |
| # define NLM4_OFFSET_MAX ((s64) ((~(u64)0) >> 1)) |
| /* Return states for NLM */ |
| enum { |
| NLM_LCK_GRANTED = 0, |
| NLM_LCK_DENIED = 1, |
| NLM_LCK_DENIED_NOLOCKS = 2, |
| NLM_LCK_BLOCKED = 3, |
| NLM_LCK_DENIED_GRACE_PERIOD = 4, |
| #ifdef CONFIG_LOCKD_V4 |
| NLM_DEADLCK = 5, |
| NLM_ROFS = 6, |
| NLM_STALE_FH = 7, |
| NLM_FBIG = 8, |
| NLM_FAILED = 9, |
| #endif |
| }; |
| #define NLM_PROGRAM 100021 |
| #define NLMPROC_NULL 0 |
| #define NLMPROC_TEST 1 |
| #define NLMPROC_LOCK 2 |
| #define NLMPROC_CANCEL 3 |
| #define NLMPROC_UNLOCK 4 |
| #define NLMPROC_GRANTED 5 |
| #define NLMPROC_TEST_MSG 6 |
| #define NLMPROC_LOCK_MSG 7 |
| #define NLMPROC_CANCEL_MSG 8 |
| #define NLMPROC_UNLOCK_MSG 9 |
| #define NLMPROC_GRANTED_MSG 10 |
| #define NLMPROC_TEST_RES 11 |
| #define NLMPROC_LOCK_RES 12 |
| #define NLMPROC_CANCEL_RES 13 |
| #define NLMPROC_UNLOCK_RES 14 |
| #define NLMPROC_GRANTED_RES 15 |
| #define NLMPROC_NSM_NOTIFY 16 /* statd callback */ |
| #define NLMPROC_SHARE 20 |
| #define NLMPROC_UNSHARE 21 |
| #define NLMPROC_NM_LOCK 22 |
| #define NLMPROC_FREE_ALL 23 |
| #endif /* LINUX_LOCKD_NLM_H */ |